Source code

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