001// SECTION-START[License Header]
002// <editor-fold defaultstate="collapsed" desc=" Generated License ">
003/*
004 *   jDTAUS ⁑ ISO-13616
005 *   Copyright (C) Christian Schulte, 2013-222
006 *
007 *   Permission to use, copy, modify, and/or distribute this software for any
008 *   purpose with or without fee is hereby granted, provided that the above
009 *   copyright notice and this permission notice appear in all copies.
010 *
011 *   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
012 *   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
013 *   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
014 *   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
015 *   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
016 *   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
017 *   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
018 *
019 *   $JDTAUS: IbanTest.java 8925 2017-09-03 04:47:22Z schulte $
020 *
021 */
022// </editor-fold>
023// SECTION-END
024package org.jdtaus.iso13616.test;
025
026import java.io.ByteArrayOutputStream;
027import java.io.IOException;
028import java.io.ObjectInputStream;
029import java.io.ObjectOutputStream;
030import java.math.BigInteger;
031import java.text.ParsePosition;
032import java.util.ArrayList;
033import java.util.Arrays;
034import java.util.Collection;
035import java.util.HashSet;
036import java.util.IllegalFormatFlagsException;
037import java.util.Iterator;
038import java.util.LinkedList;
039import java.util.List;
040import java.util.Map;
041import java.util.Properties;
042import java.util.Set;
043import org.jdtaus.iso13616.IBAN;
044import org.jdtaus.iso13616.IbanCheckDigitsException;
045import org.jdtaus.iso13616.IbanFormat;
046import org.jdtaus.iso13616.IbanSyntaxException;
047import org.junit.Test;
048import static org.junit.Assert.assertEquals;
049import static org.junit.Assert.assertFalse;
050import static org.junit.Assert.assertNotNull;
051import static org.junit.Assert.assertNull;
052import static org.junit.Assert.assertTrue;
053import static org.junit.Assert.fail;
054
055// SECTION-START[Documentation]
056// <editor-fold defaultstate="collapsed" desc=" Generated Documentation ">
057/**
058 * Testcases for classes {@code org.jdtaus.iban.IBAN}, {@code org.jdtaus.iban.IbanSyntaxException} and {@code org.jdtaus.iban.IbanCheckDigitsException}.
059 *
060 * <dl>
061 *   <dt><b>Identifier:</b></dt><dd>jDTAUS ⁑ ISO-13616 ⁑ Tests ⁑ IBAN Test</dd>
062 *   <dt><b>Name:</b></dt><dd>jDTAUS ⁑ ISO-13616 ⁑ Tests ⁑ IBAN Test</dd>
063 *   <dt><b>Abstract:</b></dt><dd>No</dd>
064 *   <dt><b>Final:</b></dt><dd>Yes</dd>
065 *   <dt><b>Stateless:</b></dt><dd>Yes</dd>
066 * </dl>
067 *
068 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
069 * @version 1.1
070 */
071// </editor-fold>
072// SECTION-END
073// SECTION-START[Annotations]
074// <editor-fold defaultstate="collapsed" desc=" Generated Annotations ">
075@javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.9", comments = "See http://www.jomc.org/jomc/1.9/jomc-tools-1.9" )
076// </editor-fold>
077// SECTION-END
078public class IbanTest
079{
080    // SECTION-START[IbanTest]
081
082    /**
083     * Prefix for property names holding valid values formatted using electronic format.
084     */
085    private static final String VALID_ELECTRONIC_FORMAT_PREFIX = "valid.electronicformat";
086
087    /**
088     * Prefix for property names holding valid values formatted using letter format.
089     */
090    private static final String VALID_LETTER_FORMAT_PREFIX = "valid.letterformat";
091
092    /**
093     * Prefix for property names holding invalid values.
094     */
095    private static final String INVALID_PREFIX = "invalid.";
096
097    /**
098     * Set of IBAN country codes.
099     */
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}