View Javadoc

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