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