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