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 java.util.regex.Pattern;
20  import junit.framework.TestCase;
21  
22  /**
23   * ISBNValidator Test Case.
24   *
25   * @version $Revision$
26   */
27  public class ISBNValidatorTest extends TestCase {
28  
29      private final String[] validISBN10Format = new String[] {
30              "1234567890",
31              "123456789X",
32              "12345-1234567-123456-X",
33              "12345 1234567 123456 X",
34              "1-2-3-4",
35              "1 2 3 4",
36              };
37  
38      private final String[] invalidISBN10Format = new String[] {
39              "",                        // empty
40              "   ",                     // empty
41              "1",                       // too short
42              "123456789",               // too short
43              "12345678901",             // too long
44              "12345678X0",              // X not at end
45              "123456-1234567-123456-X", // Group too long
46              "12345-12345678-123456-X", // Publisher too long
47              "12345-1234567-1234567-X", // Title too long
48              "12345-1234567-123456-X2", // Check Digit too long
49              "--1 930110 99 5",         // format
50              "1 930110 99 5--",         // format
51              "1 930110-99 5-",          // format
52              "1.2.3.4",                 // Invalid Separator
53              "1=2=3=4",                 // Invalid Separator
54              "1_2_3_4",                 // Invalid Separator
55              "123456789Y",              // Other character at the end
56              "dsasdsadsa",              // invalid characters
57              "I love sparrows!",        // invalid characters
58              "068-556-98-45"            // format
59              };
60  
61      private final String[] validISBN13Format = new String[] {
62              "9781234567890",
63              "9791234567890",
64              "978-12345-1234567-123456-1",
65              "979-12345-1234567-123456-1",
66              "978 12345 1234567 123456 1",
67              "979 12345 1234567 123456 1",
68              "978-1-2-3-4",
69              "979-1-2-3-4",
70              "978 1 2 3 4",
71              "979 1 2 3 4",
72              };
73  
74      private final String[] invalidISBN13Format = new String[] {
75              "",                            // empty
76              "   ",                         // empty
77              "1",                           // too short
78              "978123456789",                // too short
79              "97812345678901",              // too long
80              "978-123456-1234567-123456-1", // Group too long
81              "978-12345-12345678-123456-1", // Publisher too long
82              "978-12345-1234567-1234567-1", // Title too long
83              "978-12345-1234567-123456-12", // Check Digit too long
84              "--978 1 930110 99 1",         // format
85              "978 1 930110 99 1--",         // format
86              "978 1 930110-99 1-",          // format
87              "123-4-567890-12-8",           // format
88              "978.1.2.3.4",                 // Invalid Separator
89              "978=1=2=3=4",                 // Invalid Separator
90              "978_1_2_3_4",                 // Invalid Separator
91              "978123456789X",               // invalid character
92              "978-0-201-63385-X",           // invalid character
93              "dsasdsadsadsa",               // invalid characters
94              "I love sparrows!",            // invalid characters
95              "979-1-234-567-89-6"           // format
96              };
97  
98      /**
99       * Create a test case with the specified name.
100      * @param name The name of the test
101      */
102     public ISBNValidatorTest(String name) {
103         super(name);
104     }
105 
106     /**
107      * Test Valid ISBN-10 formats.
108      */
109     public void testValidISBN10Format() {
110         Pattern pattern = Pattern.compile(ISBNValidator.ISBN10_REGEX);
111         for (int i = 0; i < validISBN10Format.length; i++) {
112             assertTrue("Pattern[" + i + "]=" + validISBN10Format[i], pattern.matcher(validISBN10Format[i]).matches());
113         }
114     }
115 
116     /**
117      * Test Invalid ISBN-10 formats.
118      */
119     public void testInvalidISBN10Format() {
120         ISBNValidator validator = ISBNValidator.getInstance();
121         Pattern pattern = Pattern.compile(ISBNValidator.ISBN10_REGEX);
122         for (int i = 0; i < invalidISBN10Format.length; i++) {
123             assertFalse("Pattern[" + i + "]=" + invalidISBN10Format[i],       pattern.matcher(invalidISBN10Format[i]).matches());
124             assertFalse("isValidISBN10[" + i + "]=" + invalidISBN10Format[i], validator.isValidISBN10(invalidISBN10Format[i]));
125             assertNull("validateISBN10[" + i + "]=" + invalidISBN10Format[i], validator.validateISBN10(invalidISBN10Format[i]));
126         }
127     }
128 
129     /**
130      * Test Valid ISBN-13 formats.
131      */
132     public void testValidISBN13Format() {
133         Pattern pattern = Pattern.compile(ISBNValidator.ISBN13_REGEX);
134         for (int i = 0; i < validISBN13Format.length; i++) {
135             assertTrue("Pattern[" + i + "]=" + validISBN13Format[i], pattern.matcher(validISBN13Format[i]).matches());
136         }
137     }
138 
139     /**
140      * Test Invalid ISBN-13 formats.
141      */
142     public void testInvalidISBN13Format() {
143         Pattern pattern = Pattern.compile(ISBNValidator.ISBN13_REGEX);
144         ISBNValidator validator = ISBNValidator.getInstance();
145         for (int i = 0; i < invalidISBN13Format.length; i++) {
146             assertFalse("Pattern[" + i + "]=" + invalidISBN13Format[i],       pattern.matcher(invalidISBN13Format[i]).matches());
147             assertFalse("isValidISBN13[" + i + "]=" + invalidISBN13Format[i], validator.isValidISBN13(invalidISBN13Format[i]));
148             assertNull("validateISBN13[" + i + "]=" + invalidISBN13Format[i], validator.validateISBN13(invalidISBN13Format[i]));
149         }
150     }
151 
152     /**
153      * Test isValid() ISBN-10 codes
154      */
155     public void testIsValidISBN10() {
156         ISBNValidator validator = ISBNValidator.getInstance();
157         assertTrue("isValidISBN10-1", validator.isValidISBN10("1930110995"));
158         assertTrue("isValidISBN10-2", validator.isValidISBN10("1-930110-99-5"));
159         assertTrue("isValidISBN10-3", validator.isValidISBN10("1 930110 99 5"));
160         assertTrue("isValidISBN10-4", validator.isValidISBN10("020163385X"));
161         assertTrue("isValidISBN10-5", validator.isValidISBN10("0-201-63385-X"));
162         assertTrue("isValidISBN10-6", validator.isValidISBN10("0 201 63385 X"));
163 
164         assertTrue("isValid-1", validator.isValid("1930110995"));
165         assertTrue("isValid-2", validator.isValid("1-930110-99-5"));
166         assertTrue("isValid-3", validator.isValid("1 930110 99 5"));
167         assertTrue("isValid-4", validator.isValid("020163385X"));
168         assertTrue("isValid-5", validator.isValid("0-201-63385-X"));
169         assertTrue("isValid-6", validator.isValid("0 201 63385 X"));
170     }
171 
172     /**
173      * Test isValid() ISBN-13 codes
174      */
175     public void testIsValidISBN13() {
176         ISBNValidator validator = ISBNValidator.getInstance();
177         assertTrue("isValidISBN13-1", validator.isValidISBN13("9781930110991"));
178         assertTrue("isValidISBN13-2", validator.isValidISBN13("978-1-930110-99-1"));
179         assertTrue("isValidISBN13-3", validator.isValidISBN13("978 1 930110 99 1"));
180         assertTrue("isValidISBN13-4", validator.isValidISBN13("9780201633856"));
181         assertTrue("isValidISBN13-5", validator.isValidISBN13("978-0-201-63385-6"));
182         assertTrue("isValidISBN13-6", validator.isValidISBN13("978 0 201 63385 6"));
183 
184         assertTrue("isValid-1", validator.isValid("9781930110991"));
185         assertTrue("isValid-2", validator.isValid("978-1-930110-99-1"));
186         assertTrue("isValid-3", validator.isValid("978 1 930110 99 1"));
187         assertTrue("isValid-4", validator.isValid("9780201633856"));
188         assertTrue("isValid-5", validator.isValid("978-0-201-63385-6"));
189         assertTrue("isValid-6", validator.isValid("978 0 201 63385 6"));
190     }
191 
192     /**
193      * Test validate() ISBN-10 codes (don't convert)
194      */
195     public void testValidateISBN10() {
196         ISBNValidator validator = ISBNValidator.getInstance(false);
197         assertEquals("validateISBN10-1", "1930110995", validator.validateISBN10("1930110995"));
198         assertEquals("validateISBN10-2", "1930110995", validator.validateISBN10("1-930110-99-5"));
199         assertEquals("validateISBN10-3", "1930110995", validator.validateISBN10("1 930110 99 5"));
200         assertEquals("validateISBN10-4", "020163385X", validator.validateISBN10("020163385X"));
201         assertEquals("validateISBN10-5", "020163385X", validator.validateISBN10("0-201-63385-X"));
202         assertEquals("validateISBN10-6", "020163385X", validator.validateISBN10("0 201 63385 X"));
203 
204         assertEquals("validate-1", "1930110995", validator.validate("1930110995"));
205         assertEquals("validate-2", "1930110995", validator.validate("1-930110-99-5"));
206         assertEquals("validate-3", "1930110995", validator.validate("1 930110 99 5"));
207         assertEquals("validate-4", "020163385X", validator.validate("020163385X"));
208         assertEquals("validate-5", "020163385X", validator.validate("0-201-63385-X"));
209         assertEquals("validate-6", "020163385X", validator.validate("0 201 63385 X"));
210     }
211 
212     /**
213      * Test validate() ISBN-10 codes (convert)
214      */
215     public void testValidateISBN10Convert() {
216         ISBNValidator validator = ISBNValidator.getInstance();
217         assertEquals("validate-1", "9781930110991", validator.validate("1930110995"));
218         assertEquals("validate-2", "9781930110991", validator.validate("1-930110-99-5"));
219         assertEquals("validate-3", "9781930110991", validator.validate("1 930110 99 5"));
220         assertEquals("validate-4", "9780201633856", validator.validate("020163385X"));
221         assertEquals("validate-5", "9780201633856", validator.validate("0-201-63385-X"));
222         assertEquals("validate-6", "9780201633856", validator.validate("0 201 63385 X"));
223     }
224 
225     /**
226      * Test validate() ISBN-13 codes
227      */
228     public void testValidateISBN13() {
229         ISBNValidator validator = ISBNValidator.getInstance();
230         assertEquals("validateISBN13-1", "9781930110991", validator.validateISBN13("9781930110991"));
231         assertEquals("validateISBN13-2", "9781930110991", validator.validateISBN13("978-1-930110-99-1"));
232         assertEquals("validateISBN13-3", "9781930110991", validator.validateISBN13("978 1 930110 99 1"));
233         assertEquals("validateISBN13-4", "9780201633856", validator.validateISBN13("9780201633856"));
234         assertEquals("validateISBN13-5", "9780201633856", validator.validateISBN13("978-0-201-63385-6"));
235         assertEquals("validateISBN13-6", "9780201633856", validator.validateISBN13("978 0 201 63385 6"));
236 
237         assertEquals("validate-1", "9781930110991", validator.validate("9781930110991"));
238         assertEquals("validate-2", "9781930110991", validator.validate("978-1-930110-99-1"));
239         assertEquals("validate-3", "9781930110991", validator.validate("978 1 930110 99 1"));
240         assertEquals("validate-4", "9780201633856", validator.validate("9780201633856"));
241         assertEquals("validate-5", "9780201633856", validator.validate("978-0-201-63385-6"));
242         assertEquals("validate-6", "9780201633856", validator.validate("978 0 201 63385 6"));
243     }
244 
245     /**
246      * Test null values
247      */
248     public void testNull() {
249         ISBNValidator validator = ISBNValidator.getInstance();
250         assertFalse("isValid",        validator.isValid(null));
251         assertFalse("isValidISBN10",  validator.isValidISBN10(null));
252         assertFalse("isValidISBN13",  validator.isValidISBN13(null));
253         assertNull("validate",        validator.validate(null));
254         assertNull("validateISBN10",  validator.validateISBN10(null));
255         assertNull("validateISBN13",  validator.validateISBN13(null));
256         assertNull("convertToISBN13", validator.convertToISBN13(null));
257     }
258 
259     /**
260      * Test Invalid ISBN-10 codes
261      */
262     public void testInvalid() {
263         ISBNValidator validator = ISBNValidator.getInstance();
264         String baseCode = "193011099";
265         assertFalse("ISBN10-0", validator.isValid(baseCode + "0"));
266         assertFalse("ISBN10-1", validator.isValid(baseCode + "1"));
267         assertFalse("ISBN10-2", validator.isValid(baseCode + "2"));
268         assertFalse("ISBN10-3", validator.isValid(baseCode + "3"));
269         assertFalse("ISBN10-4", validator.isValid(baseCode + "4"));
270         assertTrue("ISBN10-5",  validator.isValid(baseCode + "5")); // valid check digit
271         assertFalse("ISBN10-6", validator.isValid(baseCode + "6"));
272         assertFalse("ISBN10-7", validator.isValid(baseCode + "7"));
273         assertFalse("ISBN10-8", validator.isValid(baseCode + "8"));
274         assertFalse("ISBN10-9", validator.isValid(baseCode + "9"));
275         assertFalse("ISBN10-X", validator.isValid(baseCode + "X"));
276 
277         baseCode = "978193011099";
278         assertFalse("ISBN13-0", validator.isValid(baseCode + "0"));
279         assertTrue("ISBN13-1",  validator.isValid(baseCode + "1")); // valid check digit
280         assertFalse("ISBN13-2", validator.isValid(baseCode + "2"));
281         assertFalse("ISBN13-3", validator.isValid(baseCode + "3"));
282         assertFalse("ISBN13-4", validator.isValid(baseCode + "4"));
283         assertFalse("ISBN13-5", validator.isValid(baseCode + "5"));
284         assertFalse("ISBN13-6", validator.isValid(baseCode + "6"));
285         assertFalse("ISBN13-7", validator.isValid(baseCode + "7"));
286         assertFalse("ISBN13-8", validator.isValid(baseCode + "8"));
287         assertFalse("ISBN13-9", validator.isValid(baseCode + "9"));
288     }
289 
290     /**
291      * Test method for {@link org.apache.commons.validator.routines.ISBNValidator#convertToISBN13(java.lang.String)}.
292      */
293     public void testConversionErrors() {
294         ISBNValidator validator = ISBNValidator.getInstance();
295         String input = null;
296         try {
297             input = "123456789 ";
298             validator.convertToISBN13(input);
299             fail("Expected IllegalArgumentException for '" + input + "'"); 
300         } catch (IllegalArgumentException e) {
301             // expected result
302         }
303         try {
304             input = "12345678901";
305             validator.convertToISBN13(input);
306             fail("Expected IllegalArgumentException for '" + input + "'"); 
307         } catch (IllegalArgumentException e) {
308             // expected result
309         }
310         try {
311             input = "";
312             validator.convertToISBN13(input);
313             fail("Expected IllegalArgumentException for '" + input + "'"); 
314         } catch (IllegalArgumentException e) {
315             // expected result
316         }
317         try {
318             input = "X234567890";
319             validator.convertToISBN13(input);
320             fail("Expected IllegalArgumentException for '" + input + "'"); 
321         } catch (IllegalArgumentException e) {
322             // expected result
323         }
324     }
325 
326 }