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