View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.validator.routines;
18  
19  import junit.framework.TestCase;
20  import org.apache.commons.validator.routines.checkdigit.LuhnCheckDigit;
21  
22  /**
23   * Test the CreditCardValidator class.
24   *
25   * @version $Revision: 1128380 $ $Date: 2011-05-27 12:15:02 -0400 (Fri, 27 May 2011) $
26   */
27  public class CreditCardValidatorTest extends TestCase {
28      
29      private static final String VALID_VISA = "4417123456789113";
30      private static final String ERROR_VISA = "4417123456789112";
31      private static final String VALID_SHORT_VISA = "4222222222222";
32      private static final String ERROR_SHORT_VISA = "4222222222229";
33      private static final String VALID_AMEX = "378282246310005";
34      private static final String ERROR_AMEX = "378282246310001";
35      private static final String VALID_MASTERCARD = "5105105105105100";
36      private static final String ERROR_MASTERCARD = "5105105105105105";
37      private static final String VALID_DISCOVER = "6011000990139424";
38      private static final String ERROR_DISCOVER = "6011000990139421";
39      private static final String VALID_DISCOVER65 = "6534567890123458"; // FIXME need verified test data for Discover with "65" prefix
40      private static final String ERROR_DISCOVER65 = "6534567890123450"; // FIXME need verified test data for Discover with "65" prefix
41      private static final String VALID_DINERS = "30569309025904";
42      private static final String ERROR_DINERS = "30569309025901";
43  
44      /**
45       * Constructor for CreditCardValidatorTest.
46       */
47      public CreditCardValidatorTest(String name) {
48          super(name);
49      }
50  
51      public void testIsValid() {
52          CreditCardValidator ccv = new CreditCardValidator();
53          
54          assertNull(ccv.validate(null));
55  
56          assertFalse(ccv.isValid(null));
57          assertFalse(ccv.isValid(""));
58          assertFalse(ccv.isValid("123456789012"));   // too short
59          assertFalse(ccv.isValid("12345678901234567890"));   // too long
60          assertFalse(ccv.isValid("4417123456789112"));
61          assertFalse(ccv.isValid("4417q23456w89113"));
62          assertTrue(ccv.isValid(VALID_VISA));
63          assertTrue(ccv.isValid(VALID_SHORT_VISA));
64          assertTrue(ccv.isValid(VALID_AMEX));
65          assertTrue(ccv.isValid(VALID_MASTERCARD));
66          assertTrue(ccv.isValid(VALID_DISCOVER));
67          assertTrue(ccv.isValid(VALID_DISCOVER65));
68  
69          assertFalse(ccv.isValid(ERROR_VISA));
70          assertFalse(ccv.isValid(ERROR_SHORT_VISA));
71          assertFalse(ccv.isValid(ERROR_AMEX));
72          assertFalse(ccv.isValid(ERROR_MASTERCARD));
73          assertFalse(ccv.isValid(ERROR_DISCOVER));
74          assertFalse(ccv.isValid(ERROR_DISCOVER65));
75          
76          // disallow Visa so it should fail even with good number
77          ccv = new CreditCardValidator(CreditCardValidator.AMEX);
78          assertFalse(ccv.isValid("4417123456789113"));
79      }
80      
81      public void testAddAllowedCardType() {
82          CreditCardValidator ccv = new CreditCardValidator(CreditCardValidator.NONE);
83          // Turned off all cards so even valid numbers should fail
84          assertFalse(ccv.isValid(VALID_VISA));
85          assertFalse(ccv.isValid(VALID_AMEX));
86          assertFalse(ccv.isValid(VALID_MASTERCARD));
87          assertFalse(ccv.isValid(VALID_DISCOVER));
88          assertFalse(ccv.isValid(VALID_DINERS));
89      }
90  
91      /**
92       * Test the CodeValidator array constructor
93       */    
94      public void testArrayConstructor() {
95          CreditCardValidator ccv = new CreditCardValidator(new CodeValidator[]
96                 {CreditCardValidator.VISA_VALIDATOR, CreditCardValidator.AMEX_VALIDATOR});
97          
98          assertTrue(ccv.isValid(VALID_VISA));
99          assertTrue(ccv.isValid(VALID_SHORT_VISA));
100         assertTrue(ccv.isValid(VALID_AMEX));
101         assertFalse(ccv.isValid(VALID_MASTERCARD));
102         assertFalse(ccv.isValid(VALID_DISCOVER));
103 
104         assertFalse(ccv.isValid(ERROR_VISA));
105         assertFalse(ccv.isValid(ERROR_SHORT_VISA));
106         assertFalse(ccv.isValid(ERROR_AMEX));
107         assertFalse(ccv.isValid(ERROR_MASTERCARD));
108         assertFalse(ccv.isValid(ERROR_DISCOVER));
109 
110         try {
111             new CreditCardValidator((CodeValidator[]) null);
112             fail("Expected IllegalArgumentException");
113         } catch(IllegalArgumentException iae) {
114             // expected result
115         }
116     }
117 
118     /**
119      * Test the Amex Card validator
120      */    
121     public void testAmexValidator() {
122 
123         CodeValidator validator = CreditCardValidator.AMEX_VALIDATOR;
124         RegexValidator regex    = validator.getRegexValidator();
125 
126         // ****** Test Regular Expression ******
127         // length 15 and start with a "34" or "37"
128         assertFalse("Length 12",      regex.isValid("343456789012"));
129         assertFalse("Length 13",      regex.isValid("3434567890123"));
130         assertFalse("Length 14",      regex.isValid("34345678901234"));
131         assertTrue("Length 15",       regex.isValid("343456789012345"));
132         assertFalse("Length 16",      regex.isValid("3434567890123456"));
133         assertFalse("Length 17",      regex.isValid("34345678901234567"));
134         assertFalse("Length 18",      regex.isValid("343456789012345678"));
135         assertFalse("Prefix 33",      regex.isValid("333456789012345"));
136         assertTrue("Prefix 34",       regex.isValid("343456789012345"));
137         assertFalse("Prefix 35",      regex.isValid("353456789012345"));
138         assertFalse("Prefix 36",      regex.isValid("363456789012345"));
139         assertTrue("Prefix 37",       regex.isValid("373456789012345"));
140         assertFalse("Prefix 38",      regex.isValid("383456789012345"));
141         assertFalse("Prefix 41",      regex.isValid("413456789012345"));
142         assertFalse("Invalid Char",   regex.isValid("3434567x9012345"));
143 
144         // *********** Test Validator **********
145         assertTrue("Valid regex",     regex.isValid(ERROR_AMEX));
146         assertFalse("Invalid",        validator.isValid(ERROR_AMEX));
147         assertNull("validate()",      validator.validate(ERROR_AMEX));
148         assertEquals(VALID_AMEX,      validator.validate(VALID_AMEX));
149 
150         assertTrue("Amex",            validator.isValid(VALID_AMEX));
151         assertFalse("Diners",         validator.isValid(VALID_DINERS));
152         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
153         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
154         assertFalse("Visa",           validator.isValid(VALID_VISA));
155         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
156         
157         assertTrue("Valid-A",         validator.isValid("371449635398431"));
158         assertTrue("Valid-B",         validator.isValid("340000000000009"));
159         assertTrue("Valid-C",         validator.isValid("370000000000002"));
160         assertTrue("Valid-D",         validator.isValid("378734493671000"));
161     }
162 
163     /**
164      * Test the Amex Card option
165      */    
166     public void testAmexOption() {
167         CreditCardValidator validator = new CreditCardValidator(CreditCardValidator.AMEX);
168         assertFalse("Invalid",        validator.isValid(ERROR_AMEX));
169         assertNull("validate()",      validator.validate(ERROR_AMEX));
170         assertEquals(VALID_AMEX,      validator.validate(VALID_AMEX));
171 
172         assertTrue("Amex",            validator.isValid(VALID_AMEX));
173         assertFalse("Diners",         validator.isValid(VALID_DINERS));
174         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
175         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
176         assertFalse("Visa",           validator.isValid(VALID_VISA));
177         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
178     }
179 
180     /**
181      * Test the Diners Card validator
182      */    
183     public void testDinersValidator() {
184 
185         CodeValidator validator = CreditCardValidator.DINERS_VALIDATOR;
186         RegexValidator regex    = validator.getRegexValidator();
187 
188         // ****** Test Regular Expression ******
189         // length 14 and start with a "300-305" or "3095" or "36" or "38" or "39"
190         assertFalse("Length 12-300",  regex.isValid("300456789012"));
191         assertFalse("Length 12-36",   regex.isValid("363456789012"));
192         assertFalse("Length 13-300",  regex.isValid("3004567890123"));
193         assertFalse("Length 13-36",   regex.isValid("3634567890123"));
194         assertTrue("Length 14-300",   regex.isValid("30045678901234"));
195         assertTrue("Length 14-36",    regex.isValid("36345678901234"));
196         assertFalse("Length 15-300",  regex.isValid("300456789012345"));
197         assertFalse("Length 15-36",   regex.isValid("363456789012345"));
198         assertFalse("Length 16-300",  regex.isValid("3004567890123456"));
199         assertFalse("Length 16-36",   regex.isValid("3634567890123456"));
200         assertFalse("Length 17-300",  regex.isValid("30045678901234567"));
201         assertFalse("Length 17-36",   regex.isValid("36345678901234567"));
202         assertFalse("Length 18-300",  regex.isValid("300456789012345678"));
203         assertFalse("Length 18-36",   regex.isValid("363456789012345678"));
204 
205         assertTrue("Prefix 300",      regex.isValid("30045678901234"));
206         assertTrue("Prefix 301",      regex.isValid("30145678901234"));
207         assertTrue("Prefix 302",      regex.isValid("30245678901234"));
208         assertTrue("Prefix 303",      regex.isValid("30345678901234"));
209         assertTrue("Prefix 304",      regex.isValid("30445678901234"));
210         assertTrue("Prefix 305",      regex.isValid("30545678901234"));
211         assertFalse("Prefix 306",     regex.isValid("30645678901234"));
212         assertFalse("Prefix 3094",    regex.isValid("30945678901234"));
213         assertTrue( "Prefix 3095",    regex.isValid("30955678901234"));
214         assertFalse("Prefix 3096",    regex.isValid("30965678901234"));
215         assertFalse("Prefix 35",      regex.isValid("35345678901234"));
216         assertTrue("Prefix 36",       regex.isValid("36345678901234"));
217         assertFalse("Prefix 37",      regex.isValid("37345678901234"));
218         assertTrue("Prefix 38",       regex.isValid("38345678901234"));
219         assertTrue("Prefix 39",       regex.isValid("39345678901234"));
220 
221         assertFalse("Invalid Char-A", regex.isValid("3004567x901234"));
222         assertFalse("Invalid Char-B", regex.isValid("3634567x901234"));
223 
224         // *********** Test Validator **********
225         assertTrue("Valid regex",     regex.isValid(ERROR_DINERS));
226         assertFalse("Invalid",        validator.isValid(ERROR_DINERS));
227         assertNull("validate()",      validator.validate(ERROR_DINERS));
228         assertEquals(VALID_DINERS,    validator.validate(VALID_DINERS));
229 
230         assertFalse("Amex",           validator.isValid(VALID_AMEX));
231         assertTrue("Diners",          validator.isValid(VALID_DINERS));
232         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
233         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
234         assertFalse("Visa",           validator.isValid(VALID_VISA));
235         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
236         
237         assertTrue("Valid-A",         validator.isValid("30000000000004"));
238         assertTrue("Valid-B",         validator.isValid("30123456789019"));
239         assertTrue("Valid-C",         validator.isValid("36432685260294"));
240 
241     }
242 
243     /**
244      * Test the Diners Card option
245      */    
246     public void testDinersOption() {
247         CreditCardValidator validator = new CreditCardValidator(CreditCardValidator.DINERS);
248         assertFalse("Invalid",        validator.isValid(ERROR_DINERS));
249         assertNull("validate()",      validator.validate(ERROR_DINERS));
250         assertEquals(VALID_DINERS,    validator.validate(VALID_DINERS));
251 
252         assertFalse("Amex",           validator.isValid(VALID_AMEX));
253         assertTrue("Diners",          validator.isValid(VALID_DINERS));
254         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
255         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
256         assertFalse("Visa",           validator.isValid(VALID_VISA));
257         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
258     }
259 
260     /**
261      * Test the Discover Card validator
262      */    
263     public void testDiscoverValidator() {
264 
265         CodeValidator validator = CreditCardValidator.DISCOVER_VALIDATOR;
266         RegexValidator regex    = validator.getRegexValidator();
267 
268         // ****** Test Regular Expression ******
269         // length 16 and start with either "6011" or or "64[4-9]" or "65"
270         assertFalse("Length 12-6011", regex.isValid("601156789012"));
271         assertFalse("Length 12-65",   regex.isValid("653456789012"));
272         assertFalse("Length 13-6011", regex.isValid("6011567890123"));
273         assertFalse("Length 13-65",   regex.isValid("6534567890123"));
274         assertFalse("Length 14-6011", regex.isValid("60115678901234"));
275         assertFalse("Length 14-65",   regex.isValid("65345678901234"));
276         assertFalse("Length 15-6011", regex.isValid("601156789012345"));
277         assertFalse("Length 15-65",   regex.isValid("653456789012345"));
278         assertTrue("Length 16-6011",  regex.isValid("6011567890123456"));
279         assertTrue("Length 16-644",   regex.isValid("6444567890123456"));
280         assertTrue("Length 16-648",   regex.isValid("6484567890123456"));
281         assertTrue("Length 16-65",    regex.isValid("6534567890123456"));
282         assertFalse("Length 17-6011", regex.isValid("60115678901234567"));
283         assertFalse("Length 17-65",   regex.isValid("65345678901234567"));
284         assertFalse("Length 18-6011", regex.isValid("601156789012345678"));
285         assertFalse("Length 18-65",   regex.isValid("653456789012345678"));
286 
287         assertFalse("Prefix 640",     regex.isValid("6404567890123456"));
288         assertFalse("Prefix 641",     regex.isValid("6414567890123456"));
289         assertFalse("Prefix 642",     regex.isValid("6424567890123456"));
290         assertFalse("Prefix 643",     regex.isValid("6434567890123456"));
291         assertFalse("Prefix 6010",    regex.isValid("6010567890123456"));
292         assertFalse("Prefix 6012",    regex.isValid("6012567890123456"));
293         assertFalse("Invalid Char",   regex.isValid("6011567x90123456"));
294 
295         // *********** Test Validator **********
296         assertTrue("Valid regex",     regex.isValid(ERROR_DISCOVER));
297         assertTrue("Valid regex65",   regex.isValid(ERROR_DISCOVER65));
298         assertFalse("Invalid",        validator.isValid(ERROR_DISCOVER));
299         assertFalse("Invalid65",      validator.isValid(ERROR_DISCOVER65));
300         assertNull("validate()",      validator.validate(ERROR_DISCOVER));
301         assertEquals(VALID_DISCOVER,  validator.validate(VALID_DISCOVER));
302         assertEquals(VALID_DISCOVER65, validator.validate(VALID_DISCOVER65));
303 
304         assertFalse("Amex",           validator.isValid(VALID_AMEX));
305         assertFalse("Diners",         validator.isValid(VALID_DINERS));
306         assertTrue("Discover",        validator.isValid(VALID_DISCOVER));
307         assertTrue("Discover",        validator.isValid(VALID_DISCOVER65));
308         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
309         assertFalse("Visa",           validator.isValid(VALID_VISA));
310         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
311         
312         assertTrue("Valid-A",         validator.isValid("6011111111111117"));
313         assertTrue("Valid-B",         validator.isValid("6011000000000004"));
314         assertTrue("Valid-C",         validator.isValid("6011000000000012"));
315 
316     }
317 
318     /**
319      * Test the Discover Card option
320      */    
321     public void testDiscoverOption() {
322         CreditCardValidator validator = new CreditCardValidator(CreditCardValidator.DISCOVER);
323         assertFalse("Invalid",        validator.isValid(ERROR_DISCOVER));
324         assertFalse("Invalid65",      validator.isValid(ERROR_DISCOVER65));
325         assertNull("validate()",      validator.validate(ERROR_DISCOVER));
326         assertEquals(VALID_DISCOVER,  validator.validate(VALID_DISCOVER));
327         assertEquals(VALID_DISCOVER65, validator.validate(VALID_DISCOVER65));
328 
329         assertFalse("Amex",           validator.isValid(VALID_AMEX));
330         assertFalse("Diners",         validator.isValid(VALID_DINERS));
331         assertTrue("Discover",        validator.isValid(VALID_DISCOVER));
332         assertTrue("Discover",        validator.isValid(VALID_DISCOVER65));
333         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
334         assertFalse("Visa",           validator.isValid(VALID_VISA));
335         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
336     }
337 
338     /**
339      * Test the Mastercard Card validator
340      */    
341     public void testMastercardValidator() {
342 
343         CodeValidator validator = CreditCardValidator.MASTERCARD_VALIDATOR;
344         RegexValidator regex    = validator.getRegexValidator();
345 
346         // ****** Test Regular Expression ******
347         // length 16 and start with a "51-55"
348         assertFalse("Length 12",      regex.isValid("513456789012"));
349         assertFalse("Length 13",      regex.isValid("5134567890123"));
350         assertFalse("Length 14",      regex.isValid("51345678901234"));
351         assertFalse("Length 15",      regex.isValid("513456789012345"));
352         assertTrue("Length 16",       regex.isValid("5134567890123456"));
353         assertFalse("Length 17",      regex.isValid("51345678901234567"));
354         assertFalse("Length 18",      regex.isValid("513456789012345678"));
355         assertFalse("Prefix 41",      regex.isValid("4134567890123456"));
356         assertFalse("Prefix 50",      regex.isValid("5034567890123456"));
357         assertTrue("Prefix 51",       regex.isValid("5134567890123456"));
358         assertTrue("Prefix 52",       regex.isValid("5234567890123456"));
359         assertTrue("Prefix 53",       regex.isValid("5334567890123456"));
360         assertTrue("Prefix 54",       regex.isValid("5434567890123456"));
361         assertTrue("Prefix 55",       regex.isValid("5534567890123456"));
362         assertFalse("Prefix 56",      regex.isValid("5634567890123456"));
363         assertFalse("Prefix 61",      regex.isValid("6134567890123456"));
364         assertFalse("Invalid Char",   regex.isValid("5134567x90123456"));
365 
366         // *********** Test Validator **********
367         assertTrue("Valid regex",     regex.isValid(ERROR_MASTERCARD));
368         assertFalse("Invalid",        validator.isValid(ERROR_MASTERCARD));
369         assertNull("validate()",      validator.validate(ERROR_MASTERCARD));
370         assertEquals(VALID_MASTERCARD, validator.validate(VALID_MASTERCARD));
371 
372         assertFalse("Amex",           validator.isValid(VALID_AMEX));
373         assertFalse("Diners",         validator.isValid(VALID_DINERS));
374         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
375         assertTrue("Mastercard",      validator.isValid(VALID_MASTERCARD));
376         assertFalse("Visa",           validator.isValid(VALID_VISA));
377         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
378         
379         assertTrue("Valid-A",         validator.isValid("5500000000000004"));
380         assertTrue("Valid-B",         validator.isValid("5424000000000015"));
381         assertTrue("Valid-C",         validator.isValid("5301250070000191"));
382         assertTrue("Valid-D",         validator.isValid("5123456789012346"));
383         assertTrue("Valid-E",         validator.isValid("5555555555554444"));
384     }
385 
386     /**
387      * Test the Mastercard Card option
388      */    
389     public void testMastercardOption() {
390         CreditCardValidator validator = new CreditCardValidator(CreditCardValidator.MASTERCARD);
391         assertFalse("Invalid",        validator.isValid(ERROR_MASTERCARD));
392         assertNull("validate()",      validator.validate(ERROR_MASTERCARD));
393         assertEquals(VALID_MASTERCARD, validator.validate(VALID_MASTERCARD));
394 
395         assertFalse("Amex",           validator.isValid(VALID_AMEX));
396         assertFalse("Diners",         validator.isValid(VALID_DINERS));
397         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
398         assertTrue("Mastercard",      validator.isValid(VALID_MASTERCARD));
399         assertFalse("Visa",           validator.isValid(VALID_VISA));
400         assertFalse("Visa Short",     validator.isValid(VALID_SHORT_VISA));
401     }
402 
403     /**
404      * Test the Visa Card validator
405      */    
406     public void testVisaValidator() {
407 
408         CodeValidator validator = CreditCardValidator.VISA_VALIDATOR;
409         RegexValidator regex    = validator.getRegexValidator();
410 
411         // ****** Test Regular Expression ******
412         // length 13 or 16, must start with a "4"
413         assertFalse("Length 12",      regex.isValid("423456789012"));
414         assertTrue("Length 13",       regex.isValid("4234567890123"));
415         assertFalse("Length 14",      regex.isValid("42345678901234"));
416         assertFalse("Length 15",      regex.isValid("423456789012345"));
417         assertTrue("Length 16",       regex.isValid("4234567890123456"));
418         assertFalse("Length 17",      regex.isValid("42345678901234567"));
419         assertFalse("Length 18",      regex.isValid("423456789012345678"));
420         assertFalse("Invalid Pref-A", regex.isValid("3234567890123"));
421         assertFalse("Invalid Pref-B", regex.isValid("3234567890123456"));
422         assertFalse("Invalid Char-A", regex.isValid("4234567x90123"));
423         assertFalse("Invalid Char-B", regex.isValid("4234567x90123456"));
424 
425         // *********** Test Validator **********
426         assertTrue("Valid regex",     regex.isValid(ERROR_VISA));
427         assertTrue("Valid regex-S",   regex.isValid(ERROR_SHORT_VISA));
428         assertFalse("Invalid",        validator.isValid(ERROR_VISA));
429         assertFalse("Invalid-S",      validator.isValid(ERROR_SHORT_VISA));
430         assertNull("validate()",      validator.validate(ERROR_VISA));
431         assertEquals(VALID_VISA,      validator.validate(VALID_VISA));
432         assertEquals(VALID_SHORT_VISA, validator.validate(VALID_SHORT_VISA));
433 
434         assertFalse("Amex",           validator.isValid(VALID_AMEX));
435         assertFalse("Diners",         validator.isValid(VALID_DINERS));
436         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
437         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
438         assertTrue("Visa",            validator.isValid(VALID_VISA));
439         assertTrue("Visa Short",      validator.isValid(VALID_SHORT_VISA));
440         
441         assertTrue("Valid-A",         validator.isValid("4111111111111111"));
442         assertTrue("Valid-C",         validator.isValid("4543059999999982"));
443         assertTrue("Valid-B",         validator.isValid("4462000000000003"));
444         assertTrue("Valid-D",         validator.isValid("4508750000000009")); // Electron
445         assertTrue("Valid-E",         validator.isValid("4012888888881881"));
446     }
447 
448     /**
449      * Test the Visa Card option
450      */    
451     public void testVisaOption() {
452         CreditCardValidator validator = new CreditCardValidator(CreditCardValidator.VISA);
453         assertFalse("Invalid",        validator.isValid(ERROR_VISA));
454         assertFalse("Invalid-S",      validator.isValid(ERROR_SHORT_VISA));
455         assertNull("validate()",      validator.validate(ERROR_VISA));
456         assertEquals(VALID_VISA,      validator.validate(VALID_VISA));
457         assertEquals(VALID_SHORT_VISA, validator.validate(VALID_SHORT_VISA));
458 
459         assertFalse("Amex",           validator.isValid(VALID_AMEX));
460         assertFalse("Diners",         validator.isValid(VALID_DINERS));
461         assertFalse("Discover",       validator.isValid(VALID_DISCOVER));
462         assertFalse("Mastercard",     validator.isValid(VALID_MASTERCARD));
463         assertTrue("Visa",            validator.isValid(VALID_VISA));
464         assertTrue("Visa Short",      validator.isValid(VALID_SHORT_VISA));
465     }
466 
467     /**
468      * Test using separators
469      */    
470     public void testMastercardUsingSeparators() {
471 
472         String MASTERCARD_REGEX_SEP = "^(5[1-5]\\d{2})(?:[- ])?(\\d{4})(?:[- ])?(\\d{4})(?:[- ])?(\\d{4})$";
473         CodeValidator validator = new CodeValidator(MASTERCARD_REGEX_SEP, LuhnCheckDigit.LUHN_CHECK_DIGIT);
474         RegexValidator regex    = validator.getRegexValidator();
475 
476         // ****** Test Regular Expression ******
477         // length 16 and start with a "51-55"
478         assertEquals("Number",  "5134567890123456", regex.validate("5134567890123456"));
479         assertEquals("Hyphen",  "5134567890123456", regex.validate("5134-5678-9012-3456"));
480         assertEquals("Space",   "5134567890123456", regex.validate("5134 5678 9012 3456"));
481         assertEquals("MixedA",  "5134567890123456", regex.validate("5134-5678 9012-3456"));
482         assertEquals("MixedB",  "5134567890123456", regex.validate("5134 5678-9012 3456"));
483 
484         assertFalse("Invalid Separator A",  regex.isValid("5134.5678.9012.3456"));
485         assertFalse("Invalid Separator B",  regex.isValid("5134_5678_9012_3456"));
486         assertFalse("Invalid Grouping A",   regex.isValid("513-45678-9012-3456"));
487         assertFalse("Invalid Grouping B",   regex.isValid("5134-567-89012-3456"));
488         assertFalse("Invalid Grouping C",   regex.isValid("5134-5678-901-23456"));
489 
490         // *********** Test Validator **********
491         assertEquals("Valid-A", "5500000000000004", validator.validate("5500-0000-0000-0004"));
492         assertEquals("Valid-B", "5424000000000015", validator.validate("5424 0000 0000 0015"));
493         assertEquals("Valid-C", "5301250070000191", validator.validate("5301-250070000191"));
494         assertEquals("Valid-D", "5123456789012346", validator.validate("5123456789012346"));
495     }
496 
497 }