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