1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package org.jdtaus.iso13616.test;
25
26 import java.io.ByteArrayOutputStream;
27 import java.io.IOException;
28 import java.io.ObjectInputStream;
29 import java.io.ObjectOutputStream;
30 import java.math.BigInteger;
31 import java.text.ParsePosition;
32 import java.util.ArrayList;
33 import java.util.Arrays;
34 import java.util.Collection;
35 import java.util.HashSet;
36 import java.util.IllegalFormatFlagsException;
37 import java.util.Iterator;
38 import java.util.LinkedList;
39 import java.util.List;
40 import java.util.Map;
41 import java.util.Properties;
42 import java.util.Set;
43 import org.jdtaus.iso13616.IBAN;
44 import org.jdtaus.iso13616.IbanCheckDigitsException;
45 import org.jdtaus.iso13616.IbanFormat;
46 import org.jdtaus.iso13616.IbanSyntaxException;
47 import org.junit.Test;
48 import static org.junit.Assert.assertEquals;
49 import static org.junit.Assert.assertFalse;
50 import static org.junit.Assert.assertNotNull;
51 import static org.junit.Assert.assertNull;
52 import static org.junit.Assert.assertTrue;
53 import static org.junit.Assert.fail;
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.9", comments = "See http://www.jomc.org/jomc/1.9/jomc-tools-1.9" )
76
77
78 public class IbanTest
79 {
80
81
82
83
84
85 private static final String VALID_ELECTRONIC_FORMAT_PREFIX = "valid.electronicformat";
86
87
88
89
90 private static final String VALID_LETTER_FORMAT_PREFIX = "valid.letterformat";
91
92
93
94
95 private static final String INVALID_PREFIX = "invalid.";
96
97
98
99
100 private static final Set<String> SPECIFIED_IBAN_COUNTRY_CODES = new HashSet<String>( 128 );
101
102
103
104
105 private static final Set<String> SPECIFIED_SEPA_COUNTRY_CODES = new HashSet<String>( 128 );
106
107 static
108 {
109
110 SPECIFIED_SEPA_COUNTRY_CODES.add( "AX" );
111 SPECIFIED_SEPA_COUNTRY_CODES.add( "AT" );
112 SPECIFIED_SEPA_COUNTRY_CODES.add( "PT" );
113 SPECIFIED_SEPA_COUNTRY_CODES.add( "BE" );
114 SPECIFIED_SEPA_COUNTRY_CODES.add( "BG" );
115 SPECIFIED_SEPA_COUNTRY_CODES.add( "HR" );
116 SPECIFIED_SEPA_COUNTRY_CODES.add( "CY" );
117 SPECIFIED_SEPA_COUNTRY_CODES.add( "CZ" );
118 SPECIFIED_SEPA_COUNTRY_CODES.add( "DK" );
119 SPECIFIED_SEPA_COUNTRY_CODES.add( "EE" );
120 SPECIFIED_SEPA_COUNTRY_CODES.add( "FI" );
121 SPECIFIED_SEPA_COUNTRY_CODES.add( "FR" );
122 SPECIFIED_SEPA_COUNTRY_CODES.add( "GF" );
123 SPECIFIED_SEPA_COUNTRY_CODES.add( "DE" );
124 SPECIFIED_SEPA_COUNTRY_CODES.add( "GI" );
125 SPECIFIED_SEPA_COUNTRY_CODES.add( "GR" );
126 SPECIFIED_SEPA_COUNTRY_CODES.add( "GP" );
127 SPECIFIED_SEPA_COUNTRY_CODES.add( "GG" );
128 SPECIFIED_SEPA_COUNTRY_CODES.add( "HU" );
129 SPECIFIED_SEPA_COUNTRY_CODES.add( "IS" );
130 SPECIFIED_SEPA_COUNTRY_CODES.add( "IE" );
131 SPECIFIED_SEPA_COUNTRY_CODES.add( "IM" );
132 SPECIFIED_SEPA_COUNTRY_CODES.add( "IT" );
133 SPECIFIED_SEPA_COUNTRY_CODES.add( "JE" );
134 SPECIFIED_SEPA_COUNTRY_CODES.add( "LV" );
135 SPECIFIED_SEPA_COUNTRY_CODES.add( "LI" );
136 SPECIFIED_SEPA_COUNTRY_CODES.add( "LT" );
137 SPECIFIED_SEPA_COUNTRY_CODES.add( "LU" );
138 SPECIFIED_SEPA_COUNTRY_CODES.add( "PT" );
139 SPECIFIED_SEPA_COUNTRY_CODES.add( "MT" );
140 SPECIFIED_SEPA_COUNTRY_CODES.add( "MQ" );
141 SPECIFIED_SEPA_COUNTRY_CODES.add( "YT" );
142 SPECIFIED_SEPA_COUNTRY_CODES.add( "MC" );
143 SPECIFIED_SEPA_COUNTRY_CODES.add( "NL" );
144 SPECIFIED_SEPA_COUNTRY_CODES.add( "NO" );
145 SPECIFIED_SEPA_COUNTRY_CODES.add( "PL" );
146 SPECIFIED_SEPA_COUNTRY_CODES.add( "RE" );
147 SPECIFIED_SEPA_COUNTRY_CODES.add( "RO" );
148 SPECIFIED_SEPA_COUNTRY_CODES.add( "BL" );
149 SPECIFIED_SEPA_COUNTRY_CODES.add( "MF" );
150 SPECIFIED_SEPA_COUNTRY_CODES.add( "PM" );
151 SPECIFIED_SEPA_COUNTRY_CODES.add( "SM" );
152 SPECIFIED_SEPA_COUNTRY_CODES.add( "SK" );
153 SPECIFIED_SEPA_COUNTRY_CODES.add( "SI" );
154 SPECIFIED_SEPA_COUNTRY_CODES.add( "ES" );
155 SPECIFIED_SEPA_COUNTRY_CODES.add( "SE" );
156 SPECIFIED_SEPA_COUNTRY_CODES.add( "CH" );
157 SPECIFIED_SEPA_COUNTRY_CODES.add( "GB" );
158
159
160 SPECIFIED_IBAN_COUNTRY_CODES.add( "AD" );
161 SPECIFIED_IBAN_COUNTRY_CODES.add( "AE" );
162 SPECIFIED_IBAN_COUNTRY_CODES.add( "AL" );
163 SPECIFIED_IBAN_COUNTRY_CODES.add( "AT" );
164 SPECIFIED_IBAN_COUNTRY_CODES.add( "AZ" );
165 SPECIFIED_IBAN_COUNTRY_CODES.add( "BA" );
166 SPECIFIED_IBAN_COUNTRY_CODES.add( "BE" );
167 SPECIFIED_IBAN_COUNTRY_CODES.add( "BG" );
168 SPECIFIED_IBAN_COUNTRY_CODES.add( "BH" );
169 SPECIFIED_IBAN_COUNTRY_CODES.add( "BR" );
170 SPECIFIED_IBAN_COUNTRY_CODES.add( "BY" );
171 SPECIFIED_IBAN_COUNTRY_CODES.add( "CH" );
172 SPECIFIED_IBAN_COUNTRY_CODES.add( "CR" );
173 SPECIFIED_IBAN_COUNTRY_CODES.add( "CY" );
174 SPECIFIED_IBAN_COUNTRY_CODES.add( "CZ" );
175 SPECIFIED_IBAN_COUNTRY_CODES.add( "DE" );
176 SPECIFIED_IBAN_COUNTRY_CODES.add( "DK" );
177 SPECIFIED_IBAN_COUNTRY_CODES.add( "DO" );
178 SPECIFIED_IBAN_COUNTRY_CODES.add( "EE" );
179 SPECIFIED_IBAN_COUNTRY_CODES.add( "ES" );
180 SPECIFIED_IBAN_COUNTRY_CODES.add( "FI" );
181 SPECIFIED_IBAN_COUNTRY_CODES.add( "AX" );
182 SPECIFIED_IBAN_COUNTRY_CODES.add( "FO" );
183 SPECIFIED_IBAN_COUNTRY_CODES.add( "FR" );
184 SPECIFIED_IBAN_COUNTRY_CODES.add( "GF" );
185 SPECIFIED_IBAN_COUNTRY_CODES.add( "GP" );
186 SPECIFIED_IBAN_COUNTRY_CODES.add( "MQ" );
187 SPECIFIED_IBAN_COUNTRY_CODES.add( "RE" );
188 SPECIFIED_IBAN_COUNTRY_CODES.add( "PF" );
189 SPECIFIED_IBAN_COUNTRY_CODES.add( "TF" );
190 SPECIFIED_IBAN_COUNTRY_CODES.add( "YT" );
191 SPECIFIED_IBAN_COUNTRY_CODES.add( "NC" );
192 SPECIFIED_IBAN_COUNTRY_CODES.add( "BL" );
193 SPECIFIED_IBAN_COUNTRY_CODES.add( "MF" );
194 SPECIFIED_IBAN_COUNTRY_CODES.add( "PM" );
195 SPECIFIED_IBAN_COUNTRY_CODES.add( "WF" );
196 SPECIFIED_IBAN_COUNTRY_CODES.add( "GB" );
197 SPECIFIED_IBAN_COUNTRY_CODES.add( "IM" );
198 SPECIFIED_IBAN_COUNTRY_CODES.add( "JE" );
199 SPECIFIED_IBAN_COUNTRY_CODES.add( "GG" );
200 SPECIFIED_IBAN_COUNTRY_CODES.add( "GE" );
201 SPECIFIED_IBAN_COUNTRY_CODES.add( "GI" );
202 SPECIFIED_IBAN_COUNTRY_CODES.add( "GL" );
203 SPECIFIED_IBAN_COUNTRY_CODES.add( "GR" );
204 SPECIFIED_IBAN_COUNTRY_CODES.add( "GT" );
205 SPECIFIED_IBAN_COUNTRY_CODES.add( "HR" );
206 SPECIFIED_IBAN_COUNTRY_CODES.add( "HU" );
207 SPECIFIED_IBAN_COUNTRY_CODES.add( "IE" );
208 SPECIFIED_IBAN_COUNTRY_CODES.add( "IL" );
209 SPECIFIED_IBAN_COUNTRY_CODES.add( "IQ" );
210 SPECIFIED_IBAN_COUNTRY_CODES.add( "IS" );
211 SPECIFIED_IBAN_COUNTRY_CODES.add( "IT" );
212 SPECIFIED_IBAN_COUNTRY_CODES.add( "JO" );
213 SPECIFIED_IBAN_COUNTRY_CODES.add( "KW" );
214 SPECIFIED_IBAN_COUNTRY_CODES.add( "KZ" );
215 SPECIFIED_IBAN_COUNTRY_CODES.add( "LB" );
216 SPECIFIED_IBAN_COUNTRY_CODES.add( "LC" );
217 SPECIFIED_IBAN_COUNTRY_CODES.add( "LI" );
218 SPECIFIED_IBAN_COUNTRY_CODES.add( "LT" );
219 SPECIFIED_IBAN_COUNTRY_CODES.add( "LU" );
220 SPECIFIED_IBAN_COUNTRY_CODES.add( "LV" );
221 SPECIFIED_IBAN_COUNTRY_CODES.add( "MC" );
222 SPECIFIED_IBAN_COUNTRY_CODES.add( "MD" );
223 SPECIFIED_IBAN_COUNTRY_CODES.add( "ME" );
224 SPECIFIED_IBAN_COUNTRY_CODES.add( "MK" );
225 SPECIFIED_IBAN_COUNTRY_CODES.add( "MR" );
226 SPECIFIED_IBAN_COUNTRY_CODES.add( "MT" );
227 SPECIFIED_IBAN_COUNTRY_CODES.add( "MU" );
228 SPECIFIED_IBAN_COUNTRY_CODES.add( "NL" );
229 SPECIFIED_IBAN_COUNTRY_CODES.add( "NO" );
230 SPECIFIED_IBAN_COUNTRY_CODES.add( "PK" );
231 SPECIFIED_IBAN_COUNTRY_CODES.add( "PL" );
232 SPECIFIED_IBAN_COUNTRY_CODES.add( "PS" );
233 SPECIFIED_IBAN_COUNTRY_CODES.add( "PT" );
234 SPECIFIED_IBAN_COUNTRY_CODES.add( "QA" );
235 SPECIFIED_IBAN_COUNTRY_CODES.add( "RO" );
236 SPECIFIED_IBAN_COUNTRY_CODES.add( "RS" );
237 SPECIFIED_IBAN_COUNTRY_CODES.add( "SA" );
238 SPECIFIED_IBAN_COUNTRY_CODES.add( "SC" );
239 SPECIFIED_IBAN_COUNTRY_CODES.add( "SE" );
240 SPECIFIED_IBAN_COUNTRY_CODES.add( "SI" );
241 SPECIFIED_IBAN_COUNTRY_CODES.add( "SK" );
242 SPECIFIED_IBAN_COUNTRY_CODES.add( "SM" );
243 SPECIFIED_IBAN_COUNTRY_CODES.add( "ST" );
244 SPECIFIED_IBAN_COUNTRY_CODES.add( "SV" );
245 SPECIFIED_IBAN_COUNTRY_CODES.add( "TL" );
246 SPECIFIED_IBAN_COUNTRY_CODES.add( "TN" );
247 SPECIFIED_IBAN_COUNTRY_CODES.add( "TR" );
248 SPECIFIED_IBAN_COUNTRY_CODES.add( "UA" );
249 SPECIFIED_IBAN_COUNTRY_CODES.add( "VG" );
250 SPECIFIED_IBAN_COUNTRY_CODES.add( "XK" );
251 }
252
253
254
255
256
257
258
259
260 private String[] getValidValuesElectronicFormat() throws IOException
261 {
262 final Map<Object, Object> properties = this.getProperties();
263 final Collection<String> col = new LinkedList<String>();
264
265 for ( final Iterator<Object> it = properties.keySet().iterator(); it.hasNext(); )
266 {
267 final String key = it.next().toString();
268 if ( key.startsWith( VALID_ELECTRONIC_FORMAT_PREFIX ) )
269 {
270 col.add( properties.get( key ).toString() );
271 }
272 }
273
274 return col.toArray( new String[ col.size() ] );
275 }
276
277
278
279
280
281
282
283
284 private String[] getValidValuesPrintFormat() throws IOException
285 {
286 final Map<Object, Object> properties = this.getProperties();
287 final Collection<String> col = new LinkedList<String>();
288
289 for ( final Iterator<Object> it = properties.keySet().iterator(); it.hasNext(); )
290 {
291 final String key = it.next().toString();
292 if ( key.startsWith( VALID_LETTER_FORMAT_PREFIX ) )
293 {
294 col.add( properties.get( key ).toString() );
295 }
296 }
297
298 return col.toArray( new String[ col.size() ] );
299 }
300
301
302
303
304
305
306
307
308 private String[] getInvalidValues() throws IOException
309 {
310 final Map<Object, Object> properties = this.getProperties();
311 final Collection<String> col = new LinkedList<String>();
312
313 for ( final Iterator<Object> it = properties.keySet().iterator(); it.hasNext(); )
314 {
315 final String key = it.next().toString();
316 if ( key.startsWith( INVALID_PREFIX ) )
317 {
318 col.add( properties.get( key ).toString() );
319 }
320 }
321
322 return col.toArray( new String[ col.size() ] );
323 }
324
325 private Map<Object, Object> getProperties() throws IOException
326 {
327 final Properties ret = new Properties();
328 ret.load( this.getClass().getResourceAsStream( "IbanTest.properties" ) );
329 return ret;
330 }
331
332 @Test public void CountryCodes() throws Exception
333 {
334 final String[] countryCodes = IBAN.getCountryCodes();
335 assertNotNull( countryCodes );
336 assertTrue( SPECIFIED_IBAN_COUNTRY_CODES.containsAll( Arrays.asList( countryCodes ) ) );
337 assertTrue( Arrays.asList( countryCodes ).containsAll( SPECIFIED_IBAN_COUNTRY_CODES ) );
338
339 final List<String> supportedCountries = new ArrayList<String>( Arrays.asList( IBAN.getCountryCodes() ) );
340 supportedCountries.removeAll( SPECIFIED_IBAN_COUNTRY_CODES );
341 assertTrue( supportedCountries.isEmpty() );
342
343 final List<String> specifiedCountries = new ArrayList<String>( SPECIFIED_IBAN_COUNTRY_CODES );
344 specifiedCountries.removeAll( Arrays.asList( IBAN.getCountryCodes() ) );
345 assertTrue( specifiedCountries.isEmpty() );
346
347
348
349
350
351
352
353
354
355 }
356
357 @Test public void SepaCountry() throws Exception
358 {
359 try
360 {
361 IBAN.isSepaCountry( null );
362 fail( "Expected 'NullPointerException' not thrown." );
363 }
364 catch ( final NullPointerException e )
365 {
366 System.out.println( e.toString() );
367 assertNotNull( e.getMessage() );
368 }
369
370 for ( final String countryCode : SPECIFIED_IBAN_COUNTRY_CODES )
371 {
372 if ( SPECIFIED_SEPA_COUNTRY_CODES.contains( countryCode ) )
373 {
374 assertTrue( "Expected SEPA country '" + countryCode + "' not found.",
375 IBAN.isSepaCountry( countryCode ) );
376
377 }
378 else
379 {
380 assertFalse( "Non-SEPA country '" + countryCode + "' flagged as SEPA.",
381 IBAN.isSepaCountry( countryCode ) );
382
383 }
384 }
385 assertFalse( IBAN.isSepaCountry( "NOT_A_COUNTRY_CODE" ) );
386 }
387
388 @Test public void CharSequence() throws Exception
389 {
390 final IBAN iban = IBAN.parse( "AL47212110090000000235698741" );
391
392 System.out.println( iban.toString() );
393
394 assertTrue( iban.length() == "AL47212110090000000235698741".length() );
395 assertTrue( iban.charAt( 0 ) == 'A' );
396 assertTrue( iban.charAt( "AL47212110090000000235698741".length() - 1 ) == '1' );
397
398 try
399 {
400 iban.charAt( "AL47212110090000000235698741".length() );
401 fail( "Expected 'IndexOutOfBoundsException' not thrown." );
402 }
403 catch ( final IndexOutOfBoundsException e )
404 {
405 System.out.println( e.toString() );
406 assertNotNull( e.getMessage() );
407 }
408
409 try
410 {
411 iban.subSequence( -1, 0 );
412 fail( "Expected 'IndexOutOfBoundsException' not thrown." );
413 }
414 catch ( final IndexOutOfBoundsException e )
415 {
416 System.out.println( e.toString() );
417 assertNotNull( e.getMessage() );
418 }
419 try
420 {
421 iban.subSequence( 0, -1 );
422 fail( "Expected 'IndexOutOfBoundsException' not thrown." );
423 }
424 catch ( final IndexOutOfBoundsException e )
425 {
426 System.out.println( e.toString() );
427 assertNotNull( e.getMessage() );
428 }
429
430 assertEquals( "AL47212110090000000235698741", iban.subSequence( 0, "AL47212110090000000235698741".length() ) );
431 assertEquals( "AL", iban.subSequence( 0, 2 ) );
432 }
433
434 @Test public void ParseElectronicFormat() throws Exception
435 {
436 final String[] valid = this.getValidValuesElectronicFormat();
437
438 for ( int i = valid.length - 1; i >= 0; i-- )
439 {
440 final IBAN iban = IBAN.parse( valid[i] );
441 assertEquals( valid[i], iban.toString( IbanFormat.ELECTRONIC ) );
442 System.out.println( iban.toString() );
443 }
444 }
445
446 @Test public void ParseLetterFormat() throws Exception
447 {
448 final String[] valid = this.getValidValuesPrintFormat();
449
450 for ( int i = valid.length - 1; i >= 0; i-- )
451 {
452 final IBAN iban = IBAN.parse( valid[i] );
453 assertEquals( valid[i], iban.toString( IbanFormat.PRINT ) );
454 System.out.println( iban.toString() );
455 }
456 }
457
458 @Test public void ParseBban() throws Exception
459 {
460 final IBAN iban = IBAN.parse( "AL47212110090000000235698741" );
461
462 try
463 {
464 IBAN.parse( "TEST", (String) null );
465 fail( "Expected 'NullPointerException' not thrown." );
466 }
467 catch ( final NullPointerException e )
468 {
469 System.out.println( e.toString() );
470 assertNotNull( e.getMessage() );
471 }
472
473 try
474 {
475 IBAN.parse( null, "TEST" );
476 fail( "Expected 'NullPointerException' not thrown." );
477 }
478 catch ( final NullPointerException e )
479 {
480 System.out.println( e.toString() );
481 assertNotNull( e.getMessage() );
482 }
483
484 try
485 {
486 IBAN.parse( "TEST", "212110090000000235698741" );
487 fail( "Expected 'IllegalArgumentException' not thrown." );
488 }
489 catch ( final IllegalArgumentException e )
490 {
491 System.out.println( e.toString() );
492 assertNotNull( e.getMessage() );
493 }
494
495 assertEquals( iban, IBAN.parse( "AL", "212110090000000235698741" ) );
496
497
498 try
499 {
500 IBAN.parse( "AL", "21211009235698741" );
501 fail( "Expected 'IbanSyntaxException' not thrown." );
502 }
503 catch ( final IbanSyntaxException e )
504 {
505 System.out.println( e.toString() );
506 assertNotNull( e.getMessage() );
507 assertTrue( e.getErrorIndex() == "21211009235698741".length() );
508 }
509 try
510 {
511 IBAN.parse( "AL", "2X2110090000000235698741" );
512 fail( "Expected 'IbanSyntaxException' not thrown." );
513 }
514 catch ( final IbanSyntaxException e )
515 {
516 System.out.println( e.toString() );
517 assertNotNull( e.getMessage() );
518 assertTrue( e.getErrorIndex() == 1 );
519 }
520 }
521
522 @Test public void ParseIbanAtPosition() throws Exception
523 {
524 final String[] validElectronicFormat = this.getValidValuesElectronicFormat();
525 final String[] validPrintFormat = this.getValidValuesPrintFormat();
526 final String[] invalid = this.getInvalidValues();
527
528 try
529 {
530 IBAN.parse( "TEST", (ParsePosition) null );
531 fail( "Expected 'NullPointerException' not thrown." );
532 }
533 catch ( final NullPointerException e )
534 {
535 System.out.println( e.toString() );
536 assertNotNull( e.getMessage() );
537 }
538
539 try
540 {
541 IBAN.parse( null, new ParsePosition( 0 ) );
542 fail( "Expected 'NullPointerException' not thrown." );
543 }
544 catch ( final NullPointerException e )
545 {
546 System.out.println( e.toString() );
547 assertNotNull( e.getMessage() );
548 }
549
550 ParsePosition pos = new ParsePosition( 0 );
551 IBAN.parse( "", pos );
552 assertTrue( pos.getErrorIndex() == 0 );
553
554 pos = new ParsePosition( 0 );
555 IBAN.parse( "0", pos );
556 assertTrue( pos.getErrorIndex() == 0 );
557
558 pos = new ParsePosition( 0 );
559 IBAN.parse( "00", pos );
560 assertTrue( pos.getErrorIndex() == 0 );
561
562 pos = new ParsePosition( 0 );
563 IBAN.parse( "X", pos );
564 assertTrue( pos.getErrorIndex() == 1 );
565
566 pos = new ParsePosition( 0 );
567 IBAN.parse( "X0", pos );
568 assertTrue( pos.getErrorIndex() == 1 );
569
570 pos = new ParsePosition( 0 );
571 IBAN.parse( "0X", pos );
572 assertTrue( pos.getErrorIndex() == 0 );
573
574 pos = new ParsePosition( 0 );
575 IBAN.parse( "XX", pos );
576 assertTrue( pos.getErrorIndex() == 1 );
577
578
579 pos = new ParsePosition( 0 );
580 IBAN.parse( "AL4721211009235698741", pos );
581 assertTrue( pos.getErrorIndex() == "AL4721211009235698741".length() );
582
583 pos = new ParsePosition( 0 );
584 IBAN.parse( "AL472X2110090000000235698741", pos );
585 assertTrue( pos.getErrorIndex() == 5 );
586
587 try
588 {
589 pos = new ParsePosition( 0 );
590 IBAN.parse( "AL00212110090000000235698741", pos );
591 fail( "Expected 'IbanCheckDigitsException' not thrown." );
592 }
593 catch ( final IbanCheckDigitsException e )
594 {
595 System.out.println( e.toString() );
596 assertNotNull( e.getMessage() );
597 assertEquals( "AL00212110090000000235698741", e.getIban() );
598 assertEquals( BigInteger.ZERO, e.getCheckDigits() );
599 }
600
601 try
602 {
603 pos = new ParsePosition( 0 );
604 IBAN.parse( "AL10 2121 1009 0000 0002 3569 8741", pos );
605 fail( "Expected 'IbanCheckDigitsException' not thrown." );
606 }
607 catch ( final IbanCheckDigitsException e )
608 {
609 System.out.println( e.toString() );
610 assertNotNull( e.getMessage() );
611 assertEquals( "AL10212110090000000235698741", e.getIban() );
612 assertEquals( BigInteger.TEN, e.getCheckDigits() );
613 }
614
615 for ( int i = validElectronicFormat.length - 1; i >= 0; i-- )
616 {
617 pos = new ParsePosition( 0 );
618 IBAN iban = IBAN.parse( validElectronicFormat[i], pos );
619 assertNotNull( iban );
620 assertTrue( pos.getErrorIndex() == -1 );
621 assertTrue( pos.getIndex() == validElectronicFormat[i].length() );
622 assertEquals( validElectronicFormat[i], iban.toString( IbanFormat.ELECTRONIC ) );
623 }
624
625 for ( int i = validPrintFormat.length - 1; i >= 0; i-- )
626 {
627 pos = new ParsePosition( 0 );
628 IBAN iban = IBAN.parse( validPrintFormat[i], pos );
629 assertNotNull( iban );
630 assertTrue( pos.getErrorIndex() == -1 );
631 assertTrue( pos.getIndex() == validPrintFormat[i].length() );
632 assertEquals( validPrintFormat[i], iban.toString( IbanFormat.PRINT ) );
633 }
634
635 for ( int i = invalid.length - 1; i >= 0; i-- )
636 {
637 pos = new ParsePosition( 0 );
638
639 if ( invalid[i].equals( "AL47 2121 1009 0000 0002 3569 8741 " )
640 || invalid[i].equals( "AL47212110090000000235698741 " ) )
641 {
642 final IBAN iban = IBAN.parse( invalid[i], pos );
643 assertNotNull( iban );
644 assertTrue( pos.getErrorIndex() == -1 );
645 assertTrue( pos.getIndex() == invalid[i].length() - 1 );
646 }
647 else
648 {
649 assertNull( "'" + invalid[i] + "'", IBAN.parse( invalid[i], pos ) );
650 assertTrue( "'" + invalid[i] + "'", pos.getErrorIndex() >= 0 );
651 }
652 }
653 }
654
655 @Test public void ParseIban() throws Exception
656 {
657 final String[] validElectronicFormat = this.getValidValuesElectronicFormat();
658 final String[] validPrintFormat = this.getValidValuesPrintFormat();
659 final String[] invalid = this.getInvalidValues();
660
661 try
662 {
663 IBAN.parse( null );
664 fail( "Expected 'NullPointerException' not thrown." );
665 }
666 catch ( final NullPointerException e )
667 {
668 System.out.println( e.toString() );
669 assertNotNull( e.getMessage() );
670 }
671
672 for ( int i = validElectronicFormat.length - 1; i >= 0; i-- )
673 {
674 final IBAN iban = IBAN.parse( validElectronicFormat[i] );
675 assertNotNull( iban );
676 assertEquals( validElectronicFormat[i], iban.toString( IbanFormat.ELECTRONIC ) );
677 }
678
679 for ( int i = validPrintFormat.length - 1; i >= 0; i-- )
680 {
681 final IBAN iban = IBAN.parse( validPrintFormat[i] );
682 assertNotNull( iban );
683 assertEquals( validPrintFormat[i], iban.toString( IbanFormat.PRINT ) );
684 }
685
686 for ( int i = invalid.length - 1; i >= 0; i-- )
687 {
688 try
689 {
690 IBAN.parse( invalid[i] );
691 fail( "Expected 'IbanSyntaxException' not thrown." );
692 }
693 catch ( final IbanSyntaxException e )
694 {
695 System.out.println( e.toString() );
696 assertNotNull( e.getMessage() );
697 }
698 }
699 }
700
701 @Test public void ValueOf() throws Exception
702 {
703 final String[] validElectronicFormatValues = this.getValidValuesElectronicFormat();
704 final String[] validPrintFormatValues = this.getValidValuesPrintFormat();
705 final String[] invalidValues = this.getInvalidValues();
706
707 try
708 {
709 IBAN.valueOf( null );
710 fail( "Expected 'NullPointerException' not thrown." );
711 }
712 catch ( final NullPointerException e )
713 {
714 System.out.println( e.toString() );
715 assertNotNull( e.getMessage() );
716 }
717
718 for ( int i = validElectronicFormatValues.length - 1; i >= 0; i-- )
719 {
720 final IBAN iban = IBAN.valueOf( validElectronicFormatValues[i] );
721 assertEquals( validElectronicFormatValues[i], iban.toString( IbanFormat.ELECTRONIC ) );
722 System.out.println( iban.toString() );
723 }
724 for ( int i = validPrintFormatValues.length - 1; i >= 0; i-- )
725 {
726 final IBAN iban = IBAN.valueOf( validPrintFormatValues[i] );
727 assertEquals( validPrintFormatValues[i], iban.toString( IbanFormat.PRINT ) );
728 System.out.println( iban.toString() );
729 }
730 for ( int i = invalidValues.length - 1; i >= 0; i-- )
731 {
732 try
733 {
734 IBAN.valueOf( invalidValues[i] );
735 fail( "Expected 'IllegalArgumentException' not thrown." );
736 }
737 catch ( final IllegalArgumentException e )
738 {
739 System.out.println( e.toString() );
740 assertNotNull( e.getMessage() );
741 }
742 }
743
744 assertEquals( IBAN.parse( "AL47212110090000000235698741" ), IBAN.valueOf( "AL47212110090000000235698741" ) );
745
746 try
747 {
748 IBAN.valueOf( "AL10212110090000000235698741" );
749 fail( "Expected 'IllegalArgumentException' not thrown." );
750 }
751 catch ( final IllegalArgumentException e )
752 {
753 System.out.println( e.toString() );
754 assertNotNull( e.getMessage() );
755 }
756 }
757
758 @Test public void ValueOfBban() throws Exception
759 {
760 final IBAN iban = IBAN.valueOf( "AL47212110090000000235698741" );
761
762 try
763 {
764 IBAN.valueOf( "TEST", (String) null );
765 fail( "Expected 'NullPointerException' not thrown." );
766 }
767 catch ( final NullPointerException e )
768 {
769 System.out.println( e.toString() );
770 assertNotNull( e.getMessage() );
771 }
772
773 try
774 {
775 IBAN.valueOf( null, "TEST" );
776 fail( "Expected 'NullPointerException' not thrown." );
777 }
778 catch ( final NullPointerException e )
779 {
780 System.out.println( e.toString() );
781 assertNotNull( e.getMessage() );
782 }
783
784 try
785 {
786 IBAN.valueOf( "TEST", "212110090000000235698741" );
787 fail( "Expected 'IllegalArgumentException' not thrown." );
788 }
789 catch ( final IllegalArgumentException e )
790 {
791 System.out.println( e.toString() );
792 assertNotNull( e.getMessage() );
793 }
794
795 assertEquals( iban, IBAN.valueOf( "AL", "212110090000000235698741" ) );
796
797
798 try
799 {
800 IBAN.valueOf( "AL", "21211009235698741" );
801 fail( "Expected 'IllegalArgumentException' not thrown." );
802 }
803 catch ( final IllegalArgumentException e )
804 {
805 System.out.println( e.toString() );
806 assertNotNull( e.getMessage() );
807 }
808 try
809 {
810 IBAN.parse( "AL", "2X2110090000000235698741" );
811 fail( "Expected 'IllegalArgumentException' not thrown." );
812 }
813 catch ( final IbanSyntaxException e )
814 {
815 System.out.println( e.toString() );
816 assertNotNull( e.getMessage() );
817 }
818 }
819
820 @Test public void PeekIban() throws Exception
821 {
822 final String[] validElectronicFormatValues = this.getValidValuesElectronicFormat();
823 final String[] validPrintFormatValues = this.getValidValuesPrintFormat();
824 final String[] invalidValues = this.getInvalidValues();
825
826 try
827 {
828 IBAN.peekIban( null );
829 fail( "Expected 'NullPointerException' not thrown." );
830 }
831 catch ( final NullPointerException e )
832 {
833 System.out.println( e.toString() );
834 assertNotNull( e.getMessage() );
835 }
836
837 for ( int i = validElectronicFormatValues.length - 1; i >= 0; i-- )
838 {
839 assertTrue( validElectronicFormatValues[i], IBAN.peekIban( validElectronicFormatValues[i] ) );
840 }
841 for ( int i = validPrintFormatValues.length - 1; i >= 0; i-- )
842 {
843 assertTrue( validPrintFormatValues[i], IBAN.peekIban( validPrintFormatValues[i] ) );
844 }
845 for ( int i = invalidValues.length - 1; i >= 0; i-- )
846 {
847 assertFalse( invalidValues[i], IBAN.peekIban( invalidValues[i] ) );
848 }
849
850 assertTrue( IBAN.peekIban( "D" ) );
851 assertTrue( IBAN.peekIban( "DE" ) );
852 assertTrue( IBAN.peekIban( "DE9" ) );
853 assertTrue( IBAN.peekIban( "DE99" ) );
854 assertTrue( IBAN.peekIban( "DE99 " ) );
855
856 assertTrue( IBAN.peekIban( "D" ) );
857 assertFalse( IBAN.peekIban( "D E" ) );
858 assertFalse( IBAN.peekIban( "DE 9" ) );
859 assertFalse( IBAN.peekIban( "DE9 9" ) );
860 assertFalse( IBAN.peekIban( "DE99 " ) );
861
862 assertFalse( IBAN.peekIban( "0" ) );
863
864 assertTrue( IBAN.peekIban( "AL47212110090000000235698741" ) );
865
866 try
867 {
868 IBAN.peekIban( "AL10212110090000000235698741" );
869 fail( "Expected 'IbanCheckDigitsException' not thrown." );
870 }
871 catch ( final IbanCheckDigitsException e )
872 {
873 System.out.println( e.toString() );
874 assertNotNull( e.getMessage() );
875 assertEquals( "AL10212110090000000235698741", e.getIban() );
876 assertEquals( BigInteger.TEN, e.getCheckDigits() );
877 }
878
879 try
880 {
881 IBAN.peekIban( "AL10 2121 1009 0000 0002 3569 8741" );
882 fail( "Expected 'IbanCheckDigitsException' not thrown." );
883 }
884 catch ( final IbanCheckDigitsException e )
885 {
886 System.out.println( e.toString() );
887 assertNotNull( e.getMessage() );
888 assertEquals( "AL10212110090000000235698741", e.getIban() );
889 assertEquals( BigInteger.TEN, e.getCheckDigits() );
890 }
891 }
892
893 @Test public void ToString() throws Exception
894 {
895 final IBAN iban = IBAN.parse( "AL47212110090000000235698741" );
896
897 try
898 {
899 iban.toString( null );
900 fail( "Expected 'NullPointerException' not thrown." );
901 }
902 catch ( final NullPointerException e )
903 {
904 System.out.println( e.toString() );
905 assertNotNull( e.getMessage() );
906 }
907
908 assertEquals( "AL47212110090000000235698741", iban.toString( IbanFormat.ELECTRONIC ) );
909 assertEquals( "AL47 2121 1009 0000 0002 3569 8741", iban.toString( IbanFormat.PRINT ) );
910 }
911
912 @Test public void Append() throws Exception
913 {
914 final IBAN iban = IBAN.parse( "AL47212110090000000235698741" );
915
916 try
917 {
918 iban.append( null, new StringBuilder() );
919 fail( "Expected 'NullPointerException' not thrown." );
920 }
921 catch ( final NullPointerException e )
922 {
923 System.out.println( e.toString() );
924 assertNotNull( e.getMessage() );
925 }
926 try
927 {
928 iban.append( IbanFormat.ELECTRONIC, null );
929 fail( "Expected 'NullPointerException' not thrown." );
930 }
931 catch ( final NullPointerException e )
932 {
933 System.out.println( e.toString() );
934 assertNotNull( e.getMessage() );
935 }
936
937 assertEquals( "AL47212110090000000235698741",
938 iban.append( IbanFormat.ELECTRONIC, new StringBuilder() ).toString() );
939
940 assertEquals( "AL47 2121 1009 0000 0002 3569 8741",
941 iban.append( IbanFormat.PRINT, new StringBuilder() ).toString() );
942
943 }
944
945 @Test public void Formattable() throws Exception
946 {
947 final IBAN iban = IBAN.parse( "AL47212110090000000235698741" );
948
949 try
950 {
951 iban.formatTo( null, -1, -1, -1 );
952 fail( "Expected 'NullPointerException' not thrown." );
953 }
954 catch ( final NullPointerException e )
955 {
956 System.out.println( e.toString() );
957 assertNotNull( e.getMessage() );
958 }
959
960 assertEquals( "AL", String.format( "%1$.2s", iban ) );
961 assertEquals( "AL", String.format( "%1$#.2s", iban ) );
962 assertEquals( "AL4721", String.format( "%1$.6s", iban ) );
963 assertEquals( "AL47 2", String.format( "%1$#.6s", iban ) );
964 assertEquals( "AL47212110090000000235698741", String.format( "%1$s", iban ) );
965 assertEquals( "AL47 2121 1009 0000 0002 3569 8741", String.format( "%1$#s", iban ) );
966 assertEquals( " AL47212110090000000235698741", String.format( "%1$50s", iban ) );
967 assertEquals( " AL47 2121 1009 0000 0002 3569 8741", String.format( "%1$#50s", iban ) );
968 assertEquals( "AL47212110090000000235698741 ", String.format( "%1$-50s", iban ) );
969 assertEquals( "AL47 2121 1009 0000 0002 3569 8741 ", String.format( "%1$-#50s", iban ) );
970
971 try
972 {
973 String.format( "%1$S", iban );
974 fail( "Expected 'IllegalFormatFlagsException' not thrown." );
975 }
976 catch ( final IllegalFormatFlagsException e )
977 {
978 System.out.println( e.toString() );
979 assertNotNull( e.getMessage() );
980 }
981
982 try
983 {
984 String.format( "%1$-50S", iban );
985 fail( "Expected 'IllegalFormatFlagsException' not thrown." );
986 }
987 catch ( final IllegalFormatFlagsException e )
988 {
989 System.out.println( e.toString() );
990 assertNotNull( e.getMessage() );
991 }
992
993 try
994 {
995 String.format( "%1$#S", iban );
996 fail( "Expected 'IllegalFormatFlagsException' not thrown." );
997 }
998 catch ( final IllegalFormatFlagsException e )
999 {
1000 System.out.println( e.toString() );
1001 assertNotNull( e.getMessage() );
1002 }
1003
1004 try
1005 {
1006 String.format( "%1$-#50S", iban );
1007 fail( "Expected 'IllegalFormatFlagsException' not thrown." );
1008 }
1009 catch ( final IllegalFormatFlagsException e )
1010 {
1011 System.out.println( e.toString() );
1012 assertNotNull( e.getMessage() );
1013 }
1014 }
1015
1016 @Test public void EqualsAndHashCode() throws Exception
1017 {
1018 final String[] electronic = this.getValidValuesElectronicFormat();
1019 final String[] print = this.getValidValuesPrintFormat();
1020
1021 for ( int i = electronic.length - 1; i >= 0; i-- )
1022 {
1023 final IBAN iban1 = IBAN.parse( electronic[i] );
1024 final IBAN iban2 = IBAN.parse( electronic[i] );
1025 assertEquals( iban1, iban2 );
1026 assertTrue( iban1.hashCode() == iban2.hashCode() );
1027 }
1028 for ( int i = print.length - 1; i >= 0; i-- )
1029 {
1030 final IBAN iban1 = IBAN.parse( print[i] );
1031 final IBAN iban2 = IBAN.parse( print[i] );
1032 assertEquals( iban1, iban2 );
1033 assertTrue( iban1.hashCode() == iban2.hashCode() );
1034 }
1035 }
1036
1037 @Test public void CompareTo() throws Exception
1038 {
1039 final String[] electronic = this.getValidValuesElectronicFormat();
1040 final String[] print = this.getValidValuesPrintFormat();
1041 final IBAN iban = IBAN.valueOf( "AL47212110090000000235698741" );
1042
1043 try
1044 {
1045 iban.compareTo( null );
1046 fail( "Expected 'NullPointerException' not thrown." );
1047 }
1048 catch ( final NullPointerException e )
1049 {
1050 System.out.println( e.toString() );
1051 assertNotNull( e.getMessage() );
1052 }
1053
1054 for ( int i = electronic.length - 1; i >= 0; i-- )
1055 {
1056 final IBAN iban1 = IBAN.parse( electronic[i] );
1057 final IBAN iban2 = IBAN.parse( electronic[i] );
1058 assertTrue( iban1.compareTo( iban2 ) == 0 );
1059 }
1060 for ( int i = print.length - 1; i >= 0; i-- )
1061 {
1062 final IBAN iban1 = IBAN.parse( print[i] );
1063 final IBAN iban2 = IBAN.parse( print[i] );
1064 assertTrue( iban1.compareTo( iban2 ) == 0 );
1065 }
1066 }
1067
1068 @Test public void Andorra()
1069 {
1070 final IBAN iban = IBAN.valueOf( "AD1200012030200359100100" );
1071 assertEquals( "0001", iban.getBankIdentifier() );
1072 assertEquals( "2030", iban.getBranchIdentifier() );
1073 assertFalse( iban.isSepaCountry() );
1074
1075 final IBAN bban = IBAN.valueOf( "AD", "00012030200359100100" );
1076 assertEquals( "0001", bban.getBankIdentifier() );
1077 assertEquals( "2030", bban.getBranchIdentifier() );
1078 assertFalse( bban.isSepaCountry() );
1079 assertEquals( bban, iban );
1080
1081 assertEquals( iban, IBAN.valueOf( "AD12 0001 2030 2003 5910 0100" ) );
1082 }
1083
1084 @Test public void TheUnitedArabEmirates()
1085 {
1086 final IBAN iban = IBAN.valueOf( "AE070331234567890123456" );
1087 assertEquals( "033", iban.getBankIdentifier() );
1088 assertNull( iban.getBranchIdentifier() );
1089 assertFalse( iban.isSepaCountry() );
1090
1091 final IBAN bban = IBAN.valueOf( "AE", "0331234567890123456" );
1092 assertEquals( "033", bban.getBankIdentifier() );
1093 assertNull( bban.getBranchIdentifier() );
1094 assertFalse( bban.isSepaCountry() );
1095 assertEquals( bban, iban );
1096
1097 assertEquals( iban, IBAN.valueOf( "AE07 0331 2345 6789 0123 456" ) );
1098 }
1099
1100 @Test public void Albania()
1101 {
1102 final IBAN iban = IBAN.valueOf( "AL47212110090000000235698741" );
1103 assertEquals( "21211009", iban.getBankIdentifier() );
1104 assertEquals( "1100", iban.getBranchIdentifier() );
1105 assertFalse( iban.isSepaCountry() );
1106
1107 final IBAN bban = IBAN.valueOf( "AL", "212110090000000235698741" );
1108 assertEquals( "21211009", bban.getBankIdentifier() );
1109 assertEquals( "1100", bban.getBranchIdentifier() );
1110 assertFalse( bban.isSepaCountry() );
1111 assertEquals( bban, iban );
1112
1113 assertEquals( iban, IBAN.valueOf( "AL47 2121 1009 0000 0002 3569 8741" ) );
1114 }
1115
1116 @Test public void Austria()
1117 {
1118 final IBAN iban = IBAN.valueOf( "AT611904300234573201" );
1119 assertEquals( "19043", iban.getBankIdentifier() );
1120 assertNull( iban.getBranchIdentifier() );
1121 assertTrue( iban.isSepaCountry() );
1122
1123 final IBAN bban = IBAN.valueOf( "AT", "1904300234573201" );
1124 assertEquals( "19043", bban.getBankIdentifier() );
1125 assertNull( bban.getBranchIdentifier() );
1126 assertTrue( bban.isSepaCountry() );
1127 assertEquals( bban, iban );
1128
1129 assertEquals( iban, IBAN.valueOf( "AT61 1904 3002 3457 3201" ) );
1130 }
1131
1132 @Test public void Azerbaijan()
1133 {
1134 final IBAN iban = IBAN.valueOf( "AZ21NABZ00000000137010001944" );
1135 assertEquals( "NABZ", iban.getBankIdentifier() );
1136 assertNull( iban.getBranchIdentifier() );
1137 assertFalse( iban.isSepaCountry() );
1138
1139 final IBAN bban = IBAN.valueOf( "AZ", "NABZ00000000137010001944" );
1140 assertEquals( "NABZ", bban.getBankIdentifier() );
1141 assertNull( bban.getBranchIdentifier() );
1142 assertFalse( bban.isSepaCountry() );
1143 assertEquals( bban, iban );
1144
1145 assertEquals( iban, IBAN.valueOf( "AZ21 NABZ 0000 0000 1370 1000 1944" ) );
1146 }
1147
1148 @Test public void BosniaAndHerzegovina()
1149 {
1150 final IBAN iban = IBAN.valueOf( "BA391290079401028494" );
1151 assertEquals( "129", iban.getBankIdentifier() );
1152 assertEquals( "007", iban.getBranchIdentifier() );
1153 assertFalse( iban.isSepaCountry() );
1154
1155 final IBAN bban = IBAN.valueOf( "BA", "1290079401028494" );
1156 assertEquals( "129", bban.getBankIdentifier() );
1157 assertEquals( "007", bban.getBranchIdentifier() );
1158 assertFalse( bban.isSepaCountry() );
1159 assertEquals( bban, iban );
1160
1161 assertEquals( iban, IBAN.valueOf( "BA39 1290 0794 0102 8494" ) );
1162 }
1163
1164 @Test public void Belgium()
1165 {
1166 final IBAN iban = IBAN.valueOf( "BE68539007547034" );
1167 assertEquals( "539", iban.getBankIdentifier() );
1168 assertNull( iban.getBranchIdentifier() );
1169 assertTrue( iban.isSepaCountry() );
1170
1171 final IBAN bban = IBAN.valueOf( "BE", "539007547034" );
1172 assertEquals( "539", bban.getBankIdentifier() );
1173 assertNull( bban.getBranchIdentifier() );
1174 assertTrue( bban.isSepaCountry() );
1175 assertEquals( bban, iban );
1176
1177 assertEquals( iban, IBAN.valueOf( "BE68 5390 0754 7034" ) );
1178 }
1179
1180 @Test public void Bulgaria()
1181 {
1182 final IBAN iban = IBAN.valueOf( "BG80BNBG96611020345678" );
1183 assertEquals( "BNBG", iban.getBankIdentifier() );
1184 assertEquals( "9661", iban.getBranchIdentifier() );
1185 assertTrue( iban.isSepaCountry() );
1186
1187 final IBAN bban = IBAN.valueOf( "BG", "BNBG96611020345678" );
1188 assertEquals( "BNBG", bban.getBankIdentifier() );
1189 assertEquals( "9661", bban.getBranchIdentifier() );
1190 assertTrue( bban.isSepaCountry() );
1191 assertEquals( bban, iban );
1192
1193 assertEquals( iban, IBAN.valueOf( "BG80 BNBG 9661 1020 3456 78" ) );
1194 }
1195
1196 @Test public void Bahrain()
1197 {
1198 final IBAN iban = IBAN.valueOf( "BH67BMAG00001299123456" );
1199 assertEquals( "BMAG", iban.getBankIdentifier() );
1200 assertNull( iban.getBranchIdentifier() );
1201 assertFalse( iban.isSepaCountry() );
1202
1203 final IBAN bban = IBAN.valueOf( "BH", "BMAG00001299123456" );
1204 assertEquals( "BMAG", bban.getBankIdentifier() );
1205 assertNull( bban.getBranchIdentifier() );
1206 assertFalse( bban.isSepaCountry() );
1207 assertEquals( bban, iban );
1208
1209 assertEquals( iban, IBAN.valueOf( "BH67 BMAG 0000 1299 1234 56" ) );
1210 }
1211
1212 @Test public void Brazil()
1213 {
1214 final IBAN iban = IBAN.valueOf( "BR1800360305000010009795493C1" );
1215 assertEquals( "00360305", iban.getBankIdentifier() );
1216 assertEquals( "00001", iban.getBranchIdentifier() );
1217 assertFalse( iban.isSepaCountry() );
1218
1219 final IBAN bban = IBAN.valueOf( "BR", "00360305000010009795493C1" );
1220 assertEquals( "00360305", bban.getBankIdentifier() );
1221 assertEquals( "00001", bban.getBranchIdentifier() );
1222 assertFalse( bban.isSepaCountry() );
1223 assertEquals( bban, iban );
1224
1225 assertEquals( iban, IBAN.valueOf( "BR18 0036 0305 0000 1000 9795 493C 1" ) );
1226 }
1227
1228 @Test public void RepublicOfBelarus()
1229 {
1230 final IBAN iban = IBAN.valueOf( "BY36NBRB3600000000000Z00AB00" );
1231 assertEquals( "NBRB", iban.getBankIdentifier() );
1232 assertNull( iban.getBranchIdentifier() );
1233 assertFalse( iban.isSepaCountry() );
1234
1235 final IBAN bban = IBAN.valueOf( "BY", "NBRB3600000000000Z00AB00" );
1236 assertEquals( "NBRB", bban.getBankIdentifier() );
1237 assertNull( bban.getBranchIdentifier() );
1238 assertFalse( bban.isSepaCountry() );
1239 assertEquals( bban, iban );
1240
1241 assertEquals( iban, IBAN.valueOf( "BY36 NBRB 3600 0000 0000 0Z00 AB00" ) );
1242 }
1243
1244 @Test public void Switzerland()
1245 {
1246 final IBAN iban = IBAN.valueOf( "CH9300762011623852957" );
1247 assertEquals( "00762", iban.getBankIdentifier() );
1248 assertNull( iban.getBranchIdentifier() );
1249 assertTrue( iban.isSepaCountry() );
1250
1251 final IBAN bban = IBAN.valueOf( "CH", "00762011623852957" );
1252 assertEquals( "00762", bban.getBankIdentifier() );
1253 assertNull( bban.getBranchIdentifier() );
1254 assertTrue( bban.isSepaCountry() );
1255 assertEquals( bban, iban );
1256
1257 assertEquals( iban, IBAN.valueOf( "CH93 0076 2011 6238 5295 7" ) );
1258 }
1259
1260 @Test public void CostaRica()
1261 {
1262 final IBAN iban = IBAN.valueOf( "CR05015202001026284066" );
1263 assertEquals( "0152", iban.getBankIdentifier() );
1264 assertNull( iban.getBranchIdentifier() );
1265 assertFalse( iban.isSepaCountry() );
1266
1267 final IBAN bban = IBAN.valueOf( "CR", "015202001026284066" );
1268 assertEquals( "0152", bban.getBankIdentifier() );
1269 assertNull( bban.getBranchIdentifier() );
1270 assertFalse( bban.isSepaCountry() );
1271 assertEquals( bban, iban );
1272
1273 assertEquals( iban, IBAN.valueOf( "CR05 0152 0200 1026 2840 66" ) );
1274 }
1275
1276 @Test public void Cyprus()
1277 {
1278 final IBAN iban = IBAN.valueOf( "CY17002001280000001200527600" );
1279 assertEquals( "002", iban.getBankIdentifier() );
1280 assertEquals( "00128", iban.getBranchIdentifier() );
1281 assertTrue( iban.isSepaCountry() );
1282
1283 final IBAN bban = IBAN.valueOf( "CY", "002001280000001200527600" );
1284 assertEquals( "002", bban.getBankIdentifier() );
1285 assertEquals( "00128", bban.getBranchIdentifier() );
1286 assertTrue( bban.isSepaCountry() );
1287 assertEquals( bban, iban );
1288
1289 assertEquals( iban, IBAN.valueOf( "CY17 0020 0128 0000 0012 0052 7600" ) );
1290 }
1291
1292 @Test public void CzechRepublic()
1293 {
1294 final IBAN iban = IBAN.valueOf( "CZ6508000000192000145399" );
1295 assertEquals( "0800", iban.getBankIdentifier() );
1296 assertNull( iban.getBranchIdentifier() );
1297 assertTrue( iban.isSepaCountry() );
1298
1299 final IBAN bban = IBAN.valueOf( "CZ", "08000000192000145399" );
1300 assertEquals( "0800", bban.getBankIdentifier() );
1301 assertNull( bban.getBranchIdentifier() );
1302 assertTrue( bban.isSepaCountry() );
1303 assertEquals( bban, iban );
1304
1305 assertEquals( iban, IBAN.valueOf( "CZ65 0800 0000 1920 0014 5399" ) );
1306 }
1307
1308 @Test public void Germany()
1309 {
1310 final IBAN iban = IBAN.valueOf( "DE89370400440532013000" );
1311 assertEquals( "37040044", iban.getBankIdentifier() );
1312 assertNull( iban.getBranchIdentifier() );
1313 assertTrue( iban.isSepaCountry() );
1314
1315 final IBAN bban = IBAN.valueOf( "DE", "370400440532013000" );
1316 assertEquals( "37040044", bban.getBankIdentifier() );
1317 assertNull( bban.getBranchIdentifier() );
1318 assertTrue( bban.isSepaCountry() );
1319 assertEquals( bban, iban );
1320
1321 assertEquals( iban, IBAN.valueOf( "DE89 3704 0044 0532 0130 00" ) );
1322 }
1323
1324 @Test public void Denmark()
1325 {
1326 final IBAN iban = IBAN.valueOf( "DK5000400440116243" );
1327 assertEquals( "0040", iban.getBankIdentifier() );
1328 assertNull( iban.getBranchIdentifier() );
1329 assertTrue( iban.isSepaCountry() );
1330
1331 final IBAN bban = IBAN.valueOf( "DK", "00400440116243" );
1332 assertEquals( "0040", bban.getBankIdentifier() );
1333 assertNull( bban.getBranchIdentifier() );
1334 assertTrue( bban.isSepaCountry() );
1335 assertEquals( bban, iban );
1336
1337 assertEquals( iban, IBAN.valueOf( "DK50 0040 0440 1162 43" ) );
1338 }
1339
1340 @Test public void DominicanRepublic()
1341 {
1342 final IBAN iban = IBAN.valueOf( "DO28BAGR00000001212453611324" );
1343 assertEquals( "BAGR", iban.getBankIdentifier() );
1344 assertNull( iban.getBranchIdentifier() );
1345 assertFalse( iban.isSepaCountry() );
1346
1347 final IBAN bban = IBAN.valueOf( "DO", "BAGR00000001212453611324" );
1348 assertEquals( "BAGR", bban.getBankIdentifier() );
1349 assertNull( bban.getBranchIdentifier() );
1350 assertFalse( bban.isSepaCountry() );
1351 assertEquals( bban, iban );
1352
1353 assertEquals( iban, IBAN.valueOf( "DO28 BAGR 0000 0001 2124 5361 1324" ) );
1354 }
1355
1356 @Test public void Estonia()
1357 {
1358 final IBAN iban = IBAN.valueOf( "EE382200221020145685" );
1359 assertEquals( "22", iban.getBankIdentifier() );
1360 assertNull( iban.getBranchIdentifier() );
1361 assertTrue( iban.isSepaCountry() );
1362
1363 final IBAN bban = IBAN.valueOf( "EE", "2200221020145685" );
1364 assertEquals( "22", bban.getBankIdentifier() );
1365 assertNull( bban.getBranchIdentifier() );
1366 assertTrue( bban.isSepaCountry() );
1367 assertEquals( bban, iban );
1368
1369 assertEquals( iban, IBAN.valueOf( "EE38 2200 2210 2014 5685" ) );
1370 }
1371
1372 @Test public void Spain()
1373 {
1374 final IBAN iban = IBAN.valueOf( "ES9121000418450200051332" );
1375 assertEquals( "2100", iban.getBankIdentifier() );
1376 assertEquals( "0418", iban.getBranchIdentifier() );
1377 assertTrue( iban.isSepaCountry() );
1378
1379 final IBAN bban = IBAN.valueOf( "ES", "21000418450200051332" );
1380 assertEquals( "2100", bban.getBankIdentifier() );
1381 assertEquals( "0418", bban.getBranchIdentifier() );
1382 assertTrue( bban.isSepaCountry() );
1383 assertEquals( bban, iban );
1384
1385 assertEquals( iban, IBAN.valueOf( "ES91 2100 0418 4502 0005 1332" ) );
1386 }
1387
1388 @Test public void Finland()
1389 {
1390 final IBAN iban = IBAN.valueOf( "FI2112345600000785" );
1391 assertEquals( "123", iban.getBankIdentifier() );
1392 assertNull( iban.getBranchIdentifier() );
1393 assertTrue( iban.isSepaCountry() );
1394
1395 IBAN bban = IBAN.valueOf( "FI", "12345600000785" );
1396 assertEquals( "123", bban.getBankIdentifier() );
1397 assertNull( bban.getBranchIdentifier() );
1398 assertTrue( bban.isSepaCountry() );
1399 assertEquals( bban, iban );
1400
1401 bban = IBAN.valueOf( "AX", "12345600000785" );
1402 assertEquals( "123", bban.getBankIdentifier() );
1403 assertNull( bban.getBranchIdentifier() );
1404 assertTrue( bban.isSepaCountry() );
1405 assertEquals( bban, iban );
1406
1407 assertEquals( iban, IBAN.valueOf( "FI21 1234 5600 0007 85" ) );
1408 }
1409
1410 @Test public void FaroeIslands()
1411 {
1412 final IBAN iban = IBAN.valueOf( "FO6264600001631634" );
1413 assertEquals( "6460", iban.getBankIdentifier() );
1414 assertNull( iban.getBranchIdentifier() );
1415 assertFalse( iban.isSepaCountry() );
1416
1417 final IBAN bban = IBAN.valueOf( "FO", "64600001631634" );
1418 assertEquals( "6460", bban.getBankIdentifier() );
1419 assertNull( bban.getBranchIdentifier() );
1420 assertFalse( bban.isSepaCountry() );
1421 assertEquals( bban, iban );
1422
1423 assertEquals( iban, IBAN.valueOf( "FO62 6460 0001 6316 34" ) );
1424 }
1425
1426 @Test public void France()
1427 {
1428 final IBAN iban = IBAN.valueOf( "FR1420041010050500013M02606" );
1429 assertEquals( "20041", iban.getBankIdentifier() );
1430 assertNull( iban.getBranchIdentifier() );
1431 assertTrue( iban.isSepaCountry() );
1432
1433 IBAN bban = IBAN.valueOf( "FR", "20041010050500013M02606" );
1434 assertEquals( "20041", bban.getBankIdentifier() );
1435 assertNull( bban.getBranchIdentifier() );
1436 assertTrue( bban.isSepaCountry() );
1437 assertEquals( bban, iban );
1438
1439 bban = IBAN.valueOf( "GF", "20041010050500013M02606" );
1440 assertEquals( "20041", bban.getBankIdentifier() );
1441 assertNull( bban.getBranchIdentifier() );
1442 assertTrue( bban.isSepaCountry() );
1443 assertEquals( bban, iban );
1444
1445 bban = IBAN.valueOf( "GP", "20041010050500013M02606" );
1446 assertEquals( "20041", bban.getBankIdentifier() );
1447 assertNull( bban.getBranchIdentifier() );
1448 assertTrue( bban.isSepaCountry() );
1449 assertEquals( bban, iban );
1450
1451 bban = IBAN.valueOf( "MQ", "20041010050500013M02606" );
1452 assertEquals( "20041", bban.getBankIdentifier() );
1453 assertNull( bban.getBranchIdentifier() );
1454 assertTrue( bban.isSepaCountry() );
1455 assertEquals( bban, iban );
1456
1457 bban = IBAN.valueOf( "RE", "20041010050500013M02606" );
1458 assertEquals( "20041", bban.getBankIdentifier() );
1459 assertNull( bban.getBranchIdentifier() );
1460 assertTrue( bban.isSepaCountry() );
1461 assertEquals( bban, iban );
1462
1463 bban = IBAN.valueOf( "PF", "20041010050500013M02606" );
1464 assertEquals( "20041", bban.getBankIdentifier() );
1465 assertNull( bban.getBranchIdentifier() );
1466 assertFalse( bban.isSepaCountry() );
1467 assertEquals( bban, iban );
1468
1469 bban = IBAN.valueOf( "TF", "20041010050500013M02606" );
1470 assertEquals( "20041", bban.getBankIdentifier() );
1471 assertNull( bban.getBranchIdentifier() );
1472 assertFalse( bban.isSepaCountry() );
1473 assertEquals( bban, iban );
1474
1475 bban = IBAN.valueOf( "YT", "20041010050500013M02606" );
1476 assertEquals( "20041", bban.getBankIdentifier() );
1477 assertNull( bban.getBranchIdentifier() );
1478 assertTrue( bban.isSepaCountry() );
1479 assertEquals( bban, iban );
1480
1481 bban = IBAN.valueOf( "NC", "20041010050500013M02606" );
1482 assertEquals( "20041", bban.getBankIdentifier() );
1483 assertNull( bban.getBranchIdentifier() );
1484 assertFalse( bban.isSepaCountry() );
1485 assertEquals( bban, iban );
1486
1487 bban = IBAN.valueOf( "BL", "20041010050500013M02606" );
1488 assertEquals( "20041", bban.getBankIdentifier() );
1489 assertNull( bban.getBranchIdentifier() );
1490 assertTrue( bban.isSepaCountry() );
1491 assertEquals( bban, iban );
1492
1493 bban = IBAN.valueOf( "MF", "20041010050500013M02606" );
1494 assertEquals( "20041", bban.getBankIdentifier() );
1495 assertNull( bban.getBranchIdentifier() );
1496 assertTrue( bban.isSepaCountry() );
1497 assertEquals( bban, iban );
1498
1499 bban = IBAN.valueOf( "PM", "20041010050500013M02606" );
1500 assertEquals( "20041", bban.getBankIdentifier() );
1501 assertNull( bban.getBranchIdentifier() );
1502 assertTrue( bban.isSepaCountry() );
1503 assertEquals( bban, iban );
1504
1505 bban = IBAN.valueOf( "WF", "20041010050500013M02606" );
1506 assertEquals( "20041", bban.getBankIdentifier() );
1507 assertNull( bban.getBranchIdentifier() );
1508 assertFalse( bban.isSepaCountry() );
1509 assertEquals( bban, iban );
1510
1511 assertEquals( iban, IBAN.valueOf( "FR14 2004 1010 0505 0001 3M02 606" ) );
1512 }
1513
1514 @Test public void UnitedKingdom()
1515 {
1516 final IBAN iban = IBAN.valueOf( "GB29NWBK60161331926819" );
1517 assertEquals( "NWBK", iban.getBankIdentifier() );
1518 assertEquals( "601613", iban.getBranchIdentifier() );
1519 assertTrue( iban.isSepaCountry() );
1520
1521 IBAN bban = IBAN.valueOf( "GB", "NWBK60161331926819" );
1522 assertEquals( "NWBK", bban.getBankIdentifier() );
1523 assertEquals( "601613", bban.getBranchIdentifier() );
1524 assertTrue( bban.isSepaCountry() );
1525 assertEquals( bban, iban );
1526
1527 bban = IBAN.valueOf( "IM", "NWBK60161331926819" );
1528 assertEquals( "NWBK", bban.getBankIdentifier() );
1529 assertEquals( "601613", bban.getBranchIdentifier() );
1530 assertTrue( bban.isSepaCountry() );
1531 assertEquals( bban, iban );
1532
1533 bban = IBAN.valueOf( "JE", "NWBK60161331926819" );
1534 assertEquals( "NWBK", bban.getBankIdentifier() );
1535 assertEquals( "601613", bban.getBranchIdentifier() );
1536 assertTrue( bban.isSepaCountry() );
1537 assertEquals( bban, iban );
1538
1539 bban = IBAN.valueOf( "GG", "NWBK60161331926819" );
1540 assertEquals( "NWBK", bban.getBankIdentifier() );
1541 assertEquals( "601613", bban.getBranchIdentifier() );
1542 assertTrue( bban.isSepaCountry() );
1543 assertEquals( bban, iban );
1544
1545 assertEquals( iban, IBAN.valueOf( "GB29 NWBK 6016 1331 9268 19" ) );
1546 }
1547
1548 @Test public void Georgia()
1549 {
1550 final IBAN iban = IBAN.valueOf( "GE29NB0000000101904917" );
1551 assertEquals( "NB", iban.getBankIdentifier() );
1552 assertNull( iban.getBranchIdentifier() );
1553 assertFalse( iban.isSepaCountry() );
1554
1555 final IBAN bban = IBAN.valueOf( "GE", "NB0000000101904917" );
1556 assertEquals( "NB", bban.getBankIdentifier() );
1557 assertNull( bban.getBranchIdentifier() );
1558 assertFalse( bban.isSepaCountry() );
1559 assertEquals( bban, iban );
1560
1561 assertEquals( iban, IBAN.valueOf( "GE29 NB00 0000 0101 9049 17" ) );
1562 }
1563
1564 @Test public void Gibraltar()
1565 {
1566 final IBAN iban = IBAN.valueOf( "GI75NWBK000000007099453" );
1567 assertEquals( "NWBK", iban.getBankIdentifier() );
1568 assertNull( iban.getBranchIdentifier() );
1569 assertTrue( iban.isSepaCountry() );
1570
1571 final IBAN bban = IBAN.valueOf( "GI", "NWBK000000007099453" );
1572 assertEquals( "NWBK", bban.getBankIdentifier() );
1573 assertNull( bban.getBranchIdentifier() );
1574 assertTrue( bban.isSepaCountry() );
1575 assertEquals( bban, iban );
1576
1577 assertEquals( iban, IBAN.valueOf( "GI75 NWBK 0000 0000 7099 453" ) );
1578 }
1579
1580 @Test public void Greenland()
1581 {
1582 final IBAN iban = IBAN.valueOf( "GL8964710001000206" );
1583 assertEquals( "6471", iban.getBankIdentifier() );
1584 assertNull( iban.getBranchIdentifier() );
1585 assertFalse( iban.isSepaCountry() );
1586
1587 final IBAN bban = IBAN.valueOf( "GL", "64710001000206" );
1588 assertEquals( "6471", bban.getBankIdentifier() );
1589 assertNull( bban.getBranchIdentifier() );
1590 assertFalse( bban.isSepaCountry() );
1591 assertEquals( bban, iban );
1592
1593 assertEquals( iban, IBAN.valueOf( "GL89 6471 0001 0002 06" ) );
1594 }
1595
1596 @Test public void Greece()
1597 {
1598 final IBAN iban = IBAN.valueOf( "GR1601101250000000012300695" );
1599 assertEquals( "011", iban.getBankIdentifier() );
1600 assertEquals( "0125", iban.getBranchIdentifier() );
1601 assertTrue( iban.isSepaCountry() );
1602
1603 final IBAN bban = IBAN.valueOf( "GR", "01101250000000012300695" );
1604 assertEquals( "011", bban.getBankIdentifier() );
1605 assertEquals( "0125", bban.getBranchIdentifier() );
1606 assertTrue( bban.isSepaCountry() );
1607 assertEquals( bban, iban );
1608
1609 assertEquals( iban, IBAN.valueOf( "GR16 0110 1250 0000 0001 2300 695" ) );
1610 }
1611
1612 @Test public void Guatemala()
1613 {
1614 final IBAN iban = IBAN.valueOf( "GT82TRAJ01020000001210029690" );
1615 assertEquals( "TRAJ", iban.getBankIdentifier() );
1616 assertNull( iban.getBranchIdentifier() );
1617 assertFalse( iban.isSepaCountry() );
1618
1619 final IBAN bban = IBAN.valueOf( "GT", "TRAJ01020000001210029690" );
1620 assertEquals( "TRAJ", bban.getBankIdentifier() );
1621 assertNull( bban.getBranchIdentifier() );
1622 assertFalse( bban.isSepaCountry() );
1623 assertEquals( bban, iban );
1624
1625 assertEquals( iban, IBAN.valueOf( "GT82 TRAJ 0102 0000 0012 1002 9690" ) );
1626 }
1627
1628 @Test public void Croatia()
1629 {
1630 final IBAN iban = IBAN.valueOf( "HR1210010051863000160" );
1631 assertEquals( "1001005", iban.getBankIdentifier() );
1632 assertNull( iban.getBranchIdentifier() );
1633 assertTrue( iban.isSepaCountry() );
1634
1635 final IBAN bban = IBAN.valueOf( "HR", "10010051863000160" );
1636 assertEquals( "1001005", bban.getBankIdentifier() );
1637 assertNull( bban.getBranchIdentifier() );
1638 assertTrue( bban.isSepaCountry() );
1639 assertEquals( bban, iban );
1640
1641 assertEquals( iban, IBAN.valueOf( "HR12 1001 0051 8630 0016 0" ) );
1642 }
1643
1644 @Test public void Hungary()
1645 {
1646 final IBAN iban = IBAN.valueOf( "HU42117730161111101800000000" );
1647 assertEquals( "117", iban.getBankIdentifier() );
1648 assertEquals( "7301", iban.getBranchIdentifier() );
1649 assertTrue( iban.isSepaCountry() );
1650
1651 final IBAN bban = IBAN.valueOf( "HU", "117730161111101800000000" );
1652 assertEquals( "117", bban.getBankIdentifier() );
1653 assertEquals( "7301", bban.getBranchIdentifier() );
1654 assertTrue( bban.isSepaCountry() );
1655 assertEquals( bban, iban );
1656
1657 assertEquals( iban, IBAN.valueOf( "HU42 1177 3016 1111 1018 0000 0000" ) );
1658 }
1659
1660 @Test public void Ireland()
1661 {
1662 final IBAN iban = IBAN.valueOf( "IE29AIBK93115212345678" );
1663 assertEquals( "AIBK", iban.getBankIdentifier() );
1664 assertEquals( "931152", iban.getBranchIdentifier() );
1665 assertTrue( iban.isSepaCountry() );
1666
1667 final IBAN bban = IBAN.valueOf( "IE", "AIBK93115212345678" );
1668 assertEquals( "AIBK", bban.getBankIdentifier() );
1669 assertEquals( "931152", bban.getBranchIdentifier() );
1670 assertTrue( bban.isSepaCountry() );
1671 assertEquals( bban, iban );
1672
1673 assertEquals( iban, IBAN.valueOf( "IE29 AIBK 9311 5212 3456 78" ) );
1674 }
1675
1676 @Test public void Israel()
1677 {
1678 final IBAN iban = IBAN.valueOf( "IL620108000000099999999" );
1679 assertEquals( "010", iban.getBankIdentifier() );
1680 assertEquals( "800", iban.getBranchIdentifier() );
1681 assertFalse( iban.isSepaCountry() );
1682
1683 final IBAN bban = IBAN.valueOf( "IL", "0108000000099999999" );
1684 assertEquals( "010", bban.getBankIdentifier() );
1685 assertEquals( "800", bban.getBranchIdentifier() );
1686 assertFalse( bban.isSepaCountry() );
1687 assertEquals( bban, iban );
1688
1689 assertEquals( iban, IBAN.valueOf( "IL62 0108 0000 0009 9999 999" ) );
1690 }
1691
1692 @Test public void Iraq()
1693 {
1694 final IBAN iban = IBAN.valueOf( "IQ98NBIQ850123456789012" );
1695 assertEquals( "NBIQ", iban.getBankIdentifier() );
1696 assertEquals( "850", iban.getBranchIdentifier() );
1697 assertFalse( iban.isSepaCountry() );
1698
1699 final IBAN bban = IBAN.valueOf( "IQ", "NBIQ850123456789012" );
1700 assertEquals( "NBIQ", bban.getBankIdentifier() );
1701 assertEquals( "850", bban.getBranchIdentifier() );
1702 assertFalse( bban.isSepaCountry() );
1703 assertEquals( bban, iban );
1704
1705 assertEquals( iban, IBAN.valueOf( "IQ98 NBIQ 8501 2345 6789 012" ) );
1706 }
1707
1708 @Test public void Iceland()
1709 {
1710 final IBAN iban = IBAN.valueOf( "IS140159260076545510730339" );
1711 assertEquals( "01", iban.getBankIdentifier() );
1712 assertEquals( "59", iban.getBranchIdentifier() );
1713 assertTrue( iban.isSepaCountry() );
1714
1715 final IBAN bban = IBAN.valueOf( "IS", "0159260076545510730339" );
1716 assertEquals( "01", bban.getBankIdentifier() );
1717 assertEquals( "59", bban.getBranchIdentifier() );
1718 assertTrue( bban.isSepaCountry() );
1719 assertEquals( bban, iban );
1720
1721 assertEquals( iban, IBAN.valueOf( "IS14 0159 2600 7654 5510 7303 39" ) );
1722 }
1723
1724 @Test public void Italy()
1725 {
1726 final IBAN iban = IBAN.valueOf( "IT60X0542811101000000123456" );
1727 assertEquals( "05428", iban.getBankIdentifier() );
1728 assertEquals( "11101", iban.getBranchIdentifier() );
1729 assertTrue( iban.isSepaCountry() );
1730
1731 final IBAN bban = IBAN.valueOf( "IT", "X0542811101000000123456" );
1732 assertEquals( "05428", bban.getBankIdentifier() );
1733 assertEquals( "11101", bban.getBranchIdentifier() );
1734 assertTrue( bban.isSepaCountry() );
1735 assertEquals( bban, iban );
1736
1737 assertEquals( iban, IBAN.valueOf( "IT60 X054 2811 1010 0000 0123 456" ) );
1738 }
1739
1740 @Test public void Jordan()
1741 {
1742
1743 final IBAN iban = IBAN.valueOf( "JO94CBJO0010000000000131000302" );
1744 assertEquals( "CBJO", iban.getBankIdentifier() );
1745 assertEquals( "0010", iban.getBranchIdentifier() );
1746 assertFalse( iban.isSepaCountry() );
1747
1748 final IBAN bban = IBAN.valueOf( "JO", "CBJO0010000000000131000302" );
1749 assertEquals( "CBJO", bban.getBankIdentifier() );
1750 assertEquals( "0010", bban.getBranchIdentifier() );
1751 assertFalse( bban.isSepaCountry() );
1752 assertEquals( bban, iban );
1753
1754 assertEquals( iban, IBAN.valueOf( "JO94 CBJO 0010 0000 0000 0131 0003 02" ) );
1755 }
1756
1757 @Test public void Kuweit()
1758 {
1759 final IBAN iban = IBAN.valueOf( "KW81CBKU0000000000001234560101" );
1760 assertEquals( "CBKU", iban.getBankIdentifier() );
1761 assertNull( iban.getBranchIdentifier() );
1762 assertFalse( iban.isSepaCountry() );
1763
1764 final IBAN bban = IBAN.valueOf( "KW", "CBKU0000000000001234560101" );
1765 assertEquals( "CBKU", bban.getBankIdentifier() );
1766 assertNull( bban.getBranchIdentifier() );
1767 assertFalse( bban.isSepaCountry() );
1768 assertEquals( bban, iban );
1769
1770 assertEquals( iban, IBAN.valueOf( "KW81 CBKU 0000 0000 0000 1234 5601 01" ) );
1771 }
1772
1773 @Test public void Kazakhstan()
1774 {
1775 final IBAN iban = IBAN.valueOf( "KZ86125KZT5004100100" );
1776 assertEquals( "125", iban.getBankIdentifier() );
1777 assertNull( iban.getBranchIdentifier() );
1778 assertFalse( iban.isSepaCountry() );
1779
1780 final IBAN bban = IBAN.valueOf( "KZ", "125KZT5004100100" );
1781 assertEquals( "125", bban.getBankIdentifier() );
1782 assertNull( bban.getBranchIdentifier() );
1783 assertFalse( bban.isSepaCountry() );
1784 assertEquals( bban, iban );
1785
1786 assertEquals( iban, IBAN.valueOf( "KZ86 125K ZT50 0410 0100" ) );
1787 }
1788
1789 @Test public void Lebanon()
1790 {
1791 final IBAN iban = IBAN.valueOf( "LB62099900000001001901229114" );
1792 assertEquals( "0999", iban.getBankIdentifier() );
1793 assertNull( iban.getBranchIdentifier() );
1794 assertFalse( iban.isSepaCountry() );
1795
1796 final IBAN bban = IBAN.valueOf( "LB", "0999 0000 0001 0019 0122 9114" );
1797 assertEquals( "0999", bban.getBankIdentifier() );
1798 assertNull( bban.getBranchIdentifier() );
1799 assertFalse( bban.isSepaCountry() );
1800 assertEquals( bban, iban );
1801
1802 assertEquals( iban, IBAN.valueOf( "LB62 0999 0000 0001 0019 0122 9114" ) );
1803 }
1804
1805 @Test public void SaintLucia()
1806 {
1807 final IBAN iban = IBAN.valueOf( "LC55HEMM000100010012001200023015" );
1808 assertEquals( "HEMM", iban.getBankIdentifier() );
1809 assertNull( iban.getBranchIdentifier() );
1810 assertFalse( iban.isSepaCountry() );
1811
1812 final IBAN bban = IBAN.valueOf( "LC", "HEMM000100010012001200023015" );
1813 assertEquals( "HEMM", bban.getBankIdentifier() );
1814 assertNull( bban.getBranchIdentifier() );
1815 assertFalse( bban.isSepaCountry() );
1816 assertEquals( bban, iban );
1817
1818 assertEquals( iban, IBAN.valueOf( "LC55 HEMM 0001 0001 0012 0012 0002 3015" ) );
1819 }
1820
1821 @Test public void Liechtenstein()
1822 {
1823 final IBAN iban = IBAN.valueOf( "LI21088100002324013AA" );
1824 assertEquals( "08810", iban.getBankIdentifier() );
1825 assertNull( iban.getBranchIdentifier() );
1826 assertTrue( iban.isSepaCountry() );
1827
1828 final IBAN bban = IBAN.valueOf( "LI", "088100002324013AA" );
1829 assertEquals( "08810", bban.getBankIdentifier() );
1830 assertNull( bban.getBranchIdentifier() );
1831 assertTrue( bban.isSepaCountry() );
1832 assertEquals( bban, iban );
1833
1834 assertEquals( iban, IBAN.valueOf( "LI21 0881 0000 2324 013A A" ) );
1835 }
1836
1837 @Test public void Lithuania()
1838 {
1839 final IBAN iban = IBAN.valueOf( "LT121000011101001000" );
1840 assertEquals( "10000", iban.getBankIdentifier() );
1841 assertNull( iban.getBranchIdentifier() );
1842 assertTrue( iban.isSepaCountry() );
1843
1844 final IBAN bban = IBAN.valueOf( "LT", "1000011101001000" );
1845 assertEquals( "10000", bban.getBankIdentifier() );
1846 assertNull( bban.getBranchIdentifier() );
1847 assertTrue( bban.isSepaCountry() );
1848 assertEquals( bban, iban );
1849
1850 assertEquals( iban, IBAN.valueOf( "LT12 1000 0111 0100 1000" ) );
1851 }
1852
1853 @Test public void Luxembourg()
1854 {
1855 final IBAN iban = IBAN.valueOf( "LU280019400644750000" );
1856 assertEquals( "001", iban.getBankIdentifier() );
1857 assertNull( iban.getBranchIdentifier() );
1858 assertTrue( iban.isSepaCountry() );
1859
1860 final IBAN bban = IBAN.valueOf( "LU", "0019400644750000" );
1861 assertEquals( "001", bban.getBankIdentifier() );
1862 assertNull( bban.getBranchIdentifier() );
1863 assertTrue( bban.isSepaCountry() );
1864 assertEquals( bban, iban );
1865
1866 assertEquals( iban, IBAN.valueOf( "LU28 0019 4006 4475 0000" ) );
1867 }
1868
1869 @Test public void Latvia()
1870 {
1871 final IBAN iban = IBAN.valueOf( "LV80BANK0000435195001" );
1872 assertEquals( "BANK", iban.getBankIdentifier() );
1873 assertNull( iban.getBranchIdentifier() );
1874 assertTrue( iban.isSepaCountry() );
1875
1876 final IBAN bban = IBAN.valueOf( "LV", "BANK0000435195001" );
1877 assertEquals( "BANK", bban.getBankIdentifier() );
1878 assertNull( bban.getBranchIdentifier() );
1879 assertTrue( bban.isSepaCountry() );
1880 assertEquals( bban, iban );
1881
1882 assertEquals( iban, IBAN.valueOf( "LV80 BANK 0000 4351 9500 1" ) );
1883 }
1884
1885 @Test public void Monaco()
1886 {
1887 final IBAN iban = IBAN.valueOf( "MC5811222000010123456789030" );
1888 assertEquals( "11222", iban.getBankIdentifier() );
1889 assertEquals( "00001", iban.getBranchIdentifier() );
1890 assertTrue( iban.isSepaCountry() );
1891
1892 final IBAN bban = IBAN.valueOf( "MC", "11222000010123456789030" );
1893 assertEquals( "11222", bban.getBankIdentifier() );
1894 assertEquals( "00001", bban.getBranchIdentifier() );
1895 assertTrue( bban.isSepaCountry() );
1896 assertEquals( bban, iban );
1897
1898 assertEquals( iban, IBAN.valueOf( "MC58 1122 2000 0101 2345 6789 030" ) );
1899 }
1900
1901 @Test public void Moldova()
1902 {
1903 final IBAN iban = IBAN.valueOf( "MD24AG000225100013104168" );
1904 assertEquals( "AG", iban.getBankIdentifier() );
1905 assertNull( iban.getBranchIdentifier() );
1906 assertFalse( iban.isSepaCountry() );
1907
1908 final IBAN bban = IBAN.valueOf( "MD", "AG000225100013104168" );
1909 assertEquals( "AG", bban.getBankIdentifier() );
1910 assertNull( bban.getBranchIdentifier() );
1911 assertFalse( bban.isSepaCountry() );
1912 assertEquals( bban, iban );
1913
1914 assertEquals( iban, IBAN.valueOf( "MD24 AG00 0225 1000 1310 4168" ) );
1915 }
1916
1917 @Test public void Montenegro()
1918 {
1919 final IBAN iban = IBAN.valueOf( "ME25505000012345678951" );
1920 assertEquals( "505", iban.getBankIdentifier() );
1921 assertNull( iban.getBranchIdentifier() );
1922 assertFalse( iban.isSepaCountry() );
1923
1924 final IBAN bban = IBAN.valueOf( "ME", "505000012345678951" );
1925 assertEquals( "505", bban.getBankIdentifier() );
1926 assertNull( bban.getBranchIdentifier() );
1927 assertFalse( bban.isSepaCountry() );
1928 assertEquals( bban, iban );
1929
1930 assertEquals( iban, IBAN.valueOf( "ME25 5050 0001 2345 6789 51" ) );
1931 }
1932
1933 @Test public void Macedonia()
1934 {
1935 final IBAN iban = IBAN.valueOf( "MK07250120000058984" );
1936 assertEquals( "250", iban.getBankIdentifier() );
1937 assertNull( iban.getBranchIdentifier() );
1938 assertFalse( iban.isSepaCountry() );
1939
1940 final IBAN bban = IBAN.valueOf( "MK", "250120000058984" );
1941 assertEquals( "250", bban.getBankIdentifier() );
1942 assertNull( bban.getBranchIdentifier() );
1943 assertFalse( bban.isSepaCountry() );
1944 assertEquals( bban, iban );
1945
1946 assertEquals( iban, IBAN.valueOf( "MK07 2501 2000 0058 984" ) );
1947 }
1948
1949 @Test public void Mauritania()
1950 {
1951 final IBAN iban = IBAN.valueOf( "MR1300020001010000123456753" );
1952 assertEquals( "00020", iban.getBankIdentifier() );
1953 assertEquals( "00101", iban.getBranchIdentifier() );
1954 assertFalse( iban.isSepaCountry() );
1955
1956 final IBAN bban = IBAN.valueOf( "MR", "00020001010000123456753" );
1957 assertEquals( "00020", bban.getBankIdentifier() );
1958 assertEquals( "00101", bban.getBranchIdentifier() );
1959 assertFalse( bban.isSepaCountry() );
1960 assertEquals( bban, iban );
1961
1962 assertEquals( iban, IBAN.valueOf( "MR13 0002 0001 0100 0012 3456 753" ) );
1963 }
1964
1965 @Test public void Malta()
1966 {
1967 final IBAN iban = IBAN.valueOf( "MT84MALT011000012345MTLCAST001S" );
1968 assertEquals( "MALT", iban.getBankIdentifier() );
1969 assertEquals( "01100", iban.getBranchIdentifier() );
1970 assertTrue( iban.isSepaCountry() );
1971
1972 final IBAN bban = IBAN.valueOf( "MT", "MALT011000012345MTLCAST001S" );
1973 assertEquals( "MALT", bban.getBankIdentifier() );
1974 assertEquals( "01100", bban.getBranchIdentifier() );
1975 assertTrue( bban.isSepaCountry() );
1976 assertEquals( bban, iban );
1977
1978 assertEquals( iban, IBAN.valueOf( "MT84 MALT 0110 0001 2345 MTLC AST0 01S" ) );
1979 }
1980
1981 @Test public void Mauritius()
1982 {
1983 final IBAN iban = IBAN.valueOf( "MU17BOMM0101101030300200000MUR" );
1984 assertEquals( "BOMM01", iban.getBankIdentifier() );
1985 assertEquals( "01", iban.getBranchIdentifier() );
1986 assertFalse( iban.isSepaCountry() );
1987
1988 final IBAN bban = IBAN.valueOf( "MU", "BOMM0101101030300200000MUR" );
1989 assertEquals( "BOMM01", bban.getBankIdentifier() );
1990 assertEquals( "01", bban.getBranchIdentifier() );
1991 assertFalse( bban.isSepaCountry() );
1992 assertEquals( bban, iban );
1993
1994 assertEquals( iban, IBAN.valueOf( "MU17 BOMM 0101 1010 3030 0200 000M UR" ) );
1995 }
1996
1997 @Test public void TheNetherlands()
1998 {
1999 final IBAN iban = IBAN.valueOf( "NL91ABNA0417164300" );
2000 assertEquals( "ABNA", iban.getBankIdentifier() );
2001 assertNull( iban.getBranchIdentifier() );
2002 assertTrue( iban.isSepaCountry() );
2003
2004 final IBAN bban = IBAN.valueOf( "NL", "ABNA0417164300" );
2005 assertEquals( "ABNA", bban.getBankIdentifier() );
2006 assertNull( bban.getBranchIdentifier() );
2007 assertTrue( bban.isSepaCountry() );
2008 assertEquals( bban, iban );
2009
2010 assertEquals( iban, IBAN.valueOf( "NL91 ABNA 0417 1643 00" ) );
2011 }
2012
2013 @Test public void Norway()
2014 {
2015 final IBAN iban = IBAN.valueOf( "NO9386011117947" );
2016 assertEquals( "8601", iban.getBankIdentifier() );
2017 assertNull( iban.getBranchIdentifier() );
2018 assertTrue( iban.isSepaCountry() );
2019
2020 final IBAN bban = IBAN.valueOf( "NO", "86011117947" );
2021 assertEquals( "8601", bban.getBankIdentifier() );
2022 assertNull( bban.getBranchIdentifier() );
2023 assertTrue( bban.isSepaCountry() );
2024 assertEquals( bban, iban );
2025
2026 assertEquals( iban, IBAN.valueOf( "NO93 8601 1117 947" ) );
2027 }
2028
2029 @Test public void Pakistan()
2030 {
2031 final IBAN iban = IBAN.valueOf( "PK36SCBL0000001123456702" );
2032 assertEquals( "SCBL", iban.getBankIdentifier() );
2033 assertNull( iban.getBranchIdentifier() );
2034 assertFalse( iban.isSepaCountry() );
2035
2036 final IBAN bban = IBAN.valueOf( "PK", "SCBL0000001123456702" );
2037 assertEquals( "SCBL", bban.getBankIdentifier() );
2038 assertNull( bban.getBranchIdentifier() );
2039 assertFalse( bban.isSepaCountry() );
2040 assertEquals( bban, iban );
2041
2042 assertEquals( iban, IBAN.valueOf( "PK36 SCBL 0000 0011 2345 6702" ) );
2043 }
2044
2045 @Test public void Poland()
2046 {
2047
2048
2049 final IBAN iban = IBAN.valueOf( "PL61109010140000071219812874" );
2050 assertEquals( "10901014", iban.getBankIdentifier() );
2051 assertNull( iban.getBranchIdentifier() );
2052 assertTrue( iban.isSepaCountry() );
2053
2054 final IBAN bban = IBAN.valueOf( "PL", "109010140000071219812874" );
2055 assertEquals( "10901014", bban.getBankIdentifier() );
2056 assertNull( bban.getBranchIdentifier() );
2057 assertTrue( bban.isSepaCountry() );
2058 assertEquals( bban, iban );
2059
2060 assertEquals( iban, IBAN.valueOf( "PL61 1090 1014 0000 0712 1981 2874" ) );
2061 }
2062
2063 @Test public void StateOfPalestine()
2064 {
2065 final IBAN iban = IBAN.valueOf( "PS92PALS000000000400123456702" );
2066 assertEquals( "PALS", iban.getBankIdentifier() );
2067 assertNull( iban.getBranchIdentifier() );
2068 assertFalse( iban.isSepaCountry() );
2069
2070 final IBAN bban = IBAN.valueOf( "PS", "PALS000000000400123456702" );
2071 assertEquals( "PALS", bban.getBankIdentifier() );
2072 assertNull( bban.getBranchIdentifier() );
2073 assertFalse( bban.isSepaCountry() );
2074 assertEquals( bban, iban );
2075
2076 assertEquals( iban, IBAN.valueOf( "PS92 PALS 0000 0000 0400 1234 5670 2" ) );
2077 }
2078
2079 @Test public void Portugal()
2080 {
2081 final IBAN iban = IBAN.valueOf( "PT50000201231234567890154" );
2082 assertEquals( "0002", iban.getBankIdentifier() );
2083 assertNull( iban.getBranchIdentifier() );
2084 assertTrue( iban.isSepaCountry() );
2085
2086 final IBAN bban = IBAN.valueOf( "PT", "000201231234567890154" );
2087 assertEquals( "0002", bban.getBankIdentifier() );
2088 assertNull( bban.getBranchIdentifier() );
2089 assertTrue( bban.isSepaCountry() );
2090 assertEquals( bban, iban );
2091
2092 assertEquals( iban, IBAN.valueOf( "PT50 0002 0123 1234 5678 9015 4" ) );
2093 }
2094
2095 @Test public void Qatar()
2096 {
2097 final IBAN iban = IBAN.valueOf( "QA58DOHB00001234567890ABCDEFG" );
2098 assertEquals( "DOHB", iban.getBankIdentifier() );
2099 assertNull( iban.getBranchIdentifier() );
2100 assertFalse( iban.isSepaCountry() );
2101
2102 final IBAN bban = IBAN.valueOf( "QA", "DOHB00001234567890ABCDEFG" );
2103 assertEquals( "DOHB", bban.getBankIdentifier() );
2104 assertNull( bban.getBranchIdentifier() );
2105 assertFalse( bban.isSepaCountry() );
2106 assertEquals( bban, iban );
2107
2108 assertEquals( iban, IBAN.valueOf( "QA58 DOHB 0000 1234 5678 90AB CDEF G" ) );
2109 }
2110
2111 @Test public void Romania()
2112 {
2113 final IBAN iban = IBAN.valueOf( "RO49AAAA1B31007593840000" );
2114 assertEquals( "AAAA", iban.getBankIdentifier() );
2115 assertNull( iban.getBranchIdentifier() );
2116 assertTrue( iban.isSepaCountry() );
2117
2118 final IBAN bban = IBAN.valueOf( "RO", "AAAA1B31007593840000" );
2119 assertEquals( "AAAA", bban.getBankIdentifier() );
2120 assertNull( bban.getBranchIdentifier() );
2121 assertTrue( bban.isSepaCountry() );
2122 assertEquals( bban, iban );
2123
2124 assertEquals( iban, IBAN.valueOf( "RO49 AAAA 1B31 0075 9384 0000" ) );
2125 }
2126
2127 @Test public void Serbia()
2128 {
2129 final IBAN iban = IBAN.valueOf( "RS35260005601001611379" );
2130 assertEquals( "260", iban.getBankIdentifier() );
2131 assertNull( iban.getBranchIdentifier() );
2132 assertFalse( iban.isSepaCountry() );
2133
2134 final IBAN bban = IBAN.valueOf( "RS", "260005601001611379" );
2135 assertEquals( "260", bban.getBankIdentifier() );
2136 assertNull( bban.getBranchIdentifier() );
2137 assertFalse( bban.isSepaCountry() );
2138 assertEquals( bban, iban );
2139
2140 assertEquals( iban, IBAN.valueOf( "RS35 2600 0560 1001 6113 79" ) );
2141 }
2142
2143 @Test public void SaudiArabia()
2144 {
2145 final IBAN iban = IBAN.valueOf( "SA0380000000608010167519" );
2146 assertEquals( "80", iban.getBankIdentifier() );
2147 assertNull( iban.getBranchIdentifier() );
2148 assertFalse( iban.isSepaCountry() );
2149
2150 final IBAN bban = IBAN.valueOf( "SA", "80000000608010167519" );
2151 assertEquals( "80", bban.getBankIdentifier() );
2152 assertNull( bban.getBranchIdentifier() );
2153 assertFalse( bban.isSepaCountry() );
2154 assertEquals( bban, iban );
2155
2156 assertEquals( iban, IBAN.valueOf( "SA03 8000 0000 6080 1016 7519" ) );
2157 }
2158
2159 @Test public void Seychelles()
2160 {
2161 final IBAN iban = IBAN.valueOf( "SC18SSCB11010000000000001497USD" );
2162 assertEquals( "SSCB11", iban.getBankIdentifier() );
2163 assertEquals( "01", iban.getBranchIdentifier() );
2164 assertFalse( iban.isSepaCountry() );
2165
2166 final IBAN bban = IBAN.valueOf( "SC", "SSCB11010000000000001497USD" );
2167 assertEquals( "SSCB11", bban.getBankIdentifier() );
2168 assertEquals( "01", bban.getBranchIdentifier() );
2169 assertFalse( bban.isSepaCountry() );
2170 assertEquals( bban, iban );
2171
2172 assertEquals( iban, IBAN.valueOf( "SC18 SSCB 1101 0000 0000 0000 1497 USD" ) );
2173 }
2174
2175 @Test public void Sweden()
2176 {
2177 final IBAN iban = IBAN.valueOf( "SE4550000000058398257466" );
2178 assertEquals( "500", iban.getBankIdentifier() );
2179 assertNull( iban.getBranchIdentifier() );
2180 assertTrue( iban.isSepaCountry() );
2181
2182 final IBAN bban = IBAN.valueOf( "SE", "50000000058398257466" );
2183 assertEquals( "500", bban.getBankIdentifier() );
2184 assertNull( bban.getBranchIdentifier() );
2185 assertTrue( bban.isSepaCountry() );
2186 assertEquals( bban, iban );
2187
2188 assertEquals( iban, IBAN.valueOf( "SE45 5000 0000 0583 9825 7466" ) );
2189 }
2190
2191 @Test public void Slovenia()
2192 {
2193 final IBAN iban = IBAN.valueOf( "SI56263300012039086" );
2194 assertEquals( "26330", iban.getBankIdentifier() );
2195 assertNull( iban.getBranchIdentifier() );
2196 assertTrue( iban.isSepaCountry() );
2197
2198 final IBAN bban = IBAN.valueOf( "SI", "263300012039086" );
2199 assertEquals( "26330", bban.getBankIdentifier() );
2200 assertNull( bban.getBranchIdentifier() );
2201 assertTrue( bban.isSepaCountry() );
2202 assertEquals( bban, iban );
2203
2204 assertEquals( iban, IBAN.valueOf( "SI56 2633 0001 2039 086" ) );
2205 }
2206
2207 @Test public void Slovakia()
2208 {
2209 final IBAN iban = IBAN.valueOf( "SK3112000000198742637541" );
2210 assertEquals( "1200", iban.getBankIdentifier() );
2211 assertNull( iban.getBranchIdentifier() );
2212 assertTrue( iban.isSepaCountry() );
2213
2214 final IBAN bban = IBAN.valueOf( "SK", "12000000198742637541" );
2215 assertEquals( "1200", bban.getBankIdentifier() );
2216 assertNull( bban.getBranchIdentifier() );
2217 assertTrue( bban.isSepaCountry() );
2218 assertEquals( bban, iban );
2219
2220 assertEquals( iban, IBAN.valueOf( "SK31 1200 0000 1987 4263 7541" ) );
2221 }
2222
2223 @Test public void SanMarino()
2224 {
2225 final IBAN iban = IBAN.valueOf( "SM86U0322509800000000270100" );
2226 assertEquals( "03225", iban.getBankIdentifier() );
2227 assertEquals( "09800", iban.getBranchIdentifier() );
2228 assertTrue( iban.isSepaCountry() );
2229
2230 final IBAN bban = IBAN.valueOf( "SM", "U0322509800000000270100" );
2231 assertEquals( "03225", bban.getBankIdentifier() );
2232 assertEquals( "09800", bban.getBranchIdentifier() );
2233 assertTrue( bban.isSepaCountry() );
2234 assertEquals( bban, iban );
2235
2236 assertEquals( iban, IBAN.valueOf( "SM86 U032 2509 8000 0000 0270 100" ) );
2237 }
2238
2239 @Test public void SaoTomeAndPrincipe()
2240 {
2241 final IBAN iban = IBAN.valueOf( "ST32000200010192194210112" );
2242 assertEquals( "0002", iban.getBankIdentifier() );
2243 assertEquals( "0001", iban.getBranchIdentifier() );
2244 assertFalse( iban.isSepaCountry() );
2245
2246 final IBAN bban = IBAN.valueOf( "ST", "000200010192194210112" );
2247 assertEquals( "0002", bban.getBankIdentifier() );
2248 assertEquals( "0001", bban.getBranchIdentifier() );
2249 assertFalse( bban.isSepaCountry() );
2250 assertEquals( bban, iban );
2251
2252 assertEquals( iban, IBAN.valueOf( "ST32 0002 0001 0192 1942 1011 2" ) );
2253 }
2254
2255 @Test public void ElSalvador()
2256 {
2257
2258 final IBAN iban = IBAN.valueOf( "SV62CENR00000000000000700025" );
2259 assertEquals( "CENR", iban.getBankIdentifier() );
2260 assertEquals( "0000", iban.getBranchIdentifier() );
2261 assertFalse( iban.isSepaCountry() );
2262
2263 final IBAN bban = IBAN.valueOf( "SV", "CENR00000000000000700025" );
2264 assertEquals( "CENR", bban.getBankIdentifier() );
2265 assertEquals( "0000", bban.getBranchIdentifier() );
2266 assertFalse( bban.isSepaCountry() );
2267 assertEquals( bban, iban );
2268
2269 assertEquals( iban, IBAN.valueOf( "SV62 CENR 0000 0000 0000 0070 0025" ) );
2270 }
2271
2272 @Test public void TimorLeste()
2273 {
2274 final IBAN iban = IBAN.valueOf( "TL380080012345678910157" );
2275 assertEquals( "008", iban.getBankIdentifier() );
2276 assertNull( iban.getBranchIdentifier() );
2277 assertFalse( iban.isSepaCountry() );
2278
2279 final IBAN bban = IBAN.valueOf( "TL", "0080012345678910157" );
2280 assertEquals( "008", bban.getBankIdentifier() );
2281 assertNull( bban.getBranchIdentifier() );
2282 assertFalse( bban.isSepaCountry() );
2283 assertEquals( bban, iban );
2284
2285 assertEquals( iban, IBAN.valueOf( "TL38 0080 0123 4567 8910 157" ) );
2286 }
2287
2288 @Test public void Tunisia()
2289 {
2290 final IBAN iban = IBAN.valueOf( "TN5910006035183598478831" );
2291 assertEquals( "10", iban.getBankIdentifier() );
2292 assertEquals( "006", iban.getBranchIdentifier() );
2293 assertFalse( iban.isSepaCountry() );
2294
2295 final IBAN bban = IBAN.valueOf( "TN", "10006035183598478831" );
2296 assertEquals( "10", bban.getBankIdentifier() );
2297 assertEquals( "006", bban.getBranchIdentifier() );
2298 assertFalse( bban.isSepaCountry() );
2299 assertEquals( bban, iban );
2300
2301 assertEquals( iban, IBAN.valueOf( "TN59 1000 6035 1835 9847 8831" ) );
2302 }
2303
2304 @Test public void Turkey()
2305 {
2306 final IBAN iban = IBAN.valueOf( "TR330006100519786457841326" );
2307 assertEquals( "00061", iban.getBankIdentifier() );
2308 assertNull( iban.getBranchIdentifier() );
2309 assertFalse( iban.isSepaCountry() );
2310
2311 final IBAN bban = IBAN.valueOf( "TR", "0006100519786457841326" );
2312 assertEquals( "00061", bban.getBankIdentifier() );
2313 assertNull( bban.getBranchIdentifier() );
2314 assertFalse( bban.isSepaCountry() );
2315 assertEquals( bban, iban );
2316
2317 assertEquals( iban, IBAN.valueOf( "TR33 0006 1005 1978 6457 8413 26" ) );
2318 }
2319
2320 @Test public void Ukraine()
2321 {
2322 final IBAN iban = IBAN.valueOf( "UA213223130000026007233566001" );
2323 assertEquals( "322313", iban.getBankIdentifier() );
2324 assertNull( iban.getBranchIdentifier() );
2325 assertFalse( iban.isSepaCountry() );
2326
2327 final IBAN bban = IBAN.valueOf( "UA", "3223130000026007233566001" );
2328 assertEquals( "322313", bban.getBankIdentifier() );
2329 assertNull( bban.getBranchIdentifier() );
2330 assertFalse( bban.isSepaCountry() );
2331 assertEquals( bban, iban );
2332
2333 assertEquals( iban, IBAN.valueOf( "UA21 3223 1300 0002 6007 2335 6600 1" ) );
2334 }
2335
2336 @Test public void VirginIslands()
2337 {
2338 final IBAN iban = IBAN.valueOf( "VG96VPVG0000012345678901" );
2339 assertEquals( "VPVG", iban.getBankIdentifier() );
2340 assertNull( iban.getBranchIdentifier() );
2341 assertFalse( iban.isSepaCountry() );
2342
2343 final IBAN bban = IBAN.valueOf( "VG", "VPVG0000012345678901" );
2344 assertEquals( "VPVG", bban.getBankIdentifier() );
2345 assertNull( bban.getBranchIdentifier() );
2346 assertFalse( bban.isSepaCountry() );
2347 assertEquals( bban, iban );
2348
2349 assertEquals( iban, IBAN.valueOf( "VG96 VPVG 0000 0123 4567 8901" ) );
2350 }
2351
2352 @Test public void Kosovo()
2353 {
2354 final IBAN iban = IBAN.valueOf( "XK051212012345678906" );
2355 assertEquals( "12", iban.getBankIdentifier() );
2356 assertEquals( "12", iban.getBranchIdentifier() );
2357 assertFalse( iban.isSepaCountry() );
2358
2359 final IBAN bban = IBAN.valueOf( "XK", "1212012345678906" );
2360 assertEquals( "12", bban.getBankIdentifier() );
2361 assertEquals( "12", bban.getBranchIdentifier() );
2362 assertFalse( bban.isSepaCountry() );
2363 assertEquals( bban, iban );
2364
2365 assertEquals( iban, IBAN.valueOf( "XK05 1212 0123 4567 8906" ) );
2366 }
2367
2368 @Test public void Serializable() throws Exception
2369 {
2370 final ObjectOutputStream out = new ObjectOutputStream( new ByteArrayOutputStream() );
2371 out.writeObject( IBAN.valueOf( "AL47212110090000000235698741" ) );
2372 out.close();
2373
2374 final ObjectInputStream in = new ObjectInputStream( this.getClass().getResourceAsStream( "IBAN.ser" ) );
2375 final IBAN iban = (IBAN) in.readObject();
2376 in.close();
2377
2378 System.out.println( iban.toString() );
2379 assertEquals( IBAN.valueOf( "AL47212110090000000235698741" ), iban );
2380 assertEquals( "AL47212110090000000235698741", iban.toString( IbanFormat.ELECTRONIC ) );
2381 assertEquals( "AL47 2121 1009 0000 0002 3569 8741", iban.toString( IbanFormat.PRINT ) );
2382 assertEquals( "212", iban.getBankIdentifier() );
2383 assertEquals( "1100", iban.getBranchIdentifier() );
2384 assertFalse( iban.isSepaCountry() );
2385 }
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398 @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.9", comments = "See http://www.jomc.org/jomc/1.9/jomc-tools-1.9" )
2399 public IbanTest()
2400 {
2401
2402 super();
2403
2404 }
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414 }