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