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    *      https://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.assertThrows;
23  import static org.junit.jupiter.api.Assertions.assertTrue;
24  
25  import java.util.regex.Pattern;
26  
27  import org.junit.jupiter.api.Test;
28  
29  /**
30   * Tests {@link ISBNValidator}.
31   */
32  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      void testConversionErrors() {
89          final ISBNValidator validator = ISBNValidator.getInstance();
90          final String input1 = "123456789 ";
91          assertThrows(IllegalArgumentException.class, () -> validator.convertToISBN13(input1), "Expected IllegalArgumentException for '" + input1 + "'");
92  
93          final String input2 = "12345678901";
94          assertThrows(IllegalArgumentException.class, () -> validator.convertToISBN13(input2), "Expected IllegalArgumentException for '" + input2 + "'");
95  
96          final String input3 = "";
97          assertThrows(IllegalArgumentException.class, () -> validator.convertToISBN13(input3), "Expected IllegalArgumentException for '" + input3 + "'");
98  
99          final String input4 = "X234567890";
100         assertThrows(IllegalArgumentException.class, () -> validator.convertToISBN13(input4), "Expected IllegalArgumentException for '" + input4 + "'");
101     }
102 
103     /**
104      * Test Invalid ISBN-10 codes
105      */
106     @Test
107     void testInvalid() {
108         final ISBNValidator validator = ISBNValidator.getInstance();
109         String baseCode = "193011099";
110         assertFalse(validator.isValid(baseCode + "0"), "ISBN10-0");
111         assertFalse(validator.isValid(baseCode + "1"), "ISBN10-1");
112         assertFalse(validator.isValid(baseCode + "2"), "ISBN10-2");
113         assertFalse(validator.isValid(baseCode + "3"), "ISBN10-3");
114         assertFalse(validator.isValid(baseCode + "4"), "ISBN10-4");
115         assertTrue(validator.isValid(baseCode + "5"), "ISBN10-5"); // valid check digit
116         assertFalse(validator.isValid(baseCode + "6"), "ISBN10-6");
117         assertFalse(validator.isValid(baseCode + "7"), "ISBN10-7");
118         assertFalse(validator.isValid(baseCode + "8"), "ISBN10-8");
119         assertFalse(validator.isValid(baseCode + "9"), "ISBN10-9");
120         assertFalse(validator.isValid(baseCode + "X"), "ISBN10-X");
121 
122         baseCode = "978193011099";
123         assertFalse(validator.isValid(baseCode + "0"), "ISBN13-0");
124         assertTrue(validator.isValid(baseCode + "1"), "ISBN13-1"); // valid check digit
125         assertFalse(validator.isValid(baseCode + "2"), "ISBN13-2");
126         assertFalse(validator.isValid(baseCode + "3"), "ISBN13-3");
127         assertFalse(validator.isValid(baseCode + "4"), "ISBN13-4");
128         assertFalse(validator.isValid(baseCode + "5"), "ISBN13-5");
129         assertFalse(validator.isValid(baseCode + "6"), "ISBN13-6");
130         assertFalse(validator.isValid(baseCode + "7"), "ISBN13-7");
131         assertFalse(validator.isValid(baseCode + "8"), "ISBN13-8");
132         assertFalse(validator.isValid(baseCode + "9"), "ISBN13-9");
133     }
134 
135     /**
136      * Test Invalid ISBN-10 formats.
137      */
138     @Test
139     void testInvalidISBN10Format() {
140         final ISBNValidator validator = ISBNValidator.getInstance();
141         final Pattern pattern = Pattern.compile(ISBNValidator.ISBN10_REGEX);
142         for (int i = 0; i < invalidISBN10Format.length; i++) {
143             assertFalse(pattern.matcher(invalidISBN10Format[i]).matches(), "Pattern[" + i + "]=" + invalidISBN10Format[i]);
144             assertFalse(validator.isValidISBN10(invalidISBN10Format[i]), "isValidISBN10[" + i + "]=" + invalidISBN10Format[i]);
145             assertNull(validator.validateISBN10(invalidISBN10Format[i]), "validateISBN10[" + i + "]=" + invalidISBN10Format[i]);
146         }
147     }
148 
149     /**
150      * Test Invalid ISBN-13 formats.
151      */
152     @Test
153     void testInvalidISBN13Format() {
154         final Pattern pattern = Pattern.compile(ISBNValidator.ISBN13_REGEX);
155         final ISBNValidator validator = ISBNValidator.getInstance();
156         for (int i = 0; i < invalidISBN13Format.length; i++) {
157             assertFalse(pattern.matcher(invalidISBN13Format[i]).matches(), "Pattern[" + i + "]=" + invalidISBN13Format[i]);
158             assertFalse(validator.isValidISBN13(invalidISBN13Format[i]), "isValidISBN13[" + i + "]=" + invalidISBN13Format[i]);
159             assertNull(validator.validateISBN13(invalidISBN13Format[i]), "validateISBN13[" + i + "]=" + invalidISBN13Format[i]);
160         }
161     }
162 
163     /**
164      * Test isValid() ISBN-10 codes
165      */
166     @Test
167     void testIsValidISBN10() {
168         final ISBNValidator validator = ISBNValidator.getInstance();
169         assertTrue(validator.isValidISBN10("1930110995"), "isValidISBN10-1");
170         assertTrue(validator.isValidISBN10("1-930110-99-5"), "isValidISBN10-2");
171         assertTrue(validator.isValidISBN10("1 930110 99 5"), "isValidISBN10-3");
172         assertTrue(validator.isValidISBN10("020163385X"), "isValidISBN10-4");
173         assertTrue(validator.isValidISBN10("0-201-63385-X"), "isValidISBN10-5");
174         assertTrue(validator.isValidISBN10("0 201 63385 X"), "isValidISBN10-6");
175 
176         assertTrue(validator.isValid("1930110995"), "isValid-1");
177         assertTrue(validator.isValid("1-930110-99-5"), "isValid-2");
178         assertTrue(validator.isValid("1 930110 99 5"), "isValid-3");
179         assertTrue(validator.isValid("020163385X"), "isValid-4");
180         assertTrue(validator.isValid("0-201-63385-X"), "isValid-5");
181         assertTrue(validator.isValid("0 201 63385 X"), "isValid-6");
182     }
183 
184     /**
185      * Test isValid() ISBN-13 codes
186      */
187     @Test
188     void testIsValidISBN13() {
189         final ISBNValidator validator = ISBNValidator.getInstance();
190         assertTrue(validator.isValidISBN13("9781930110991"), "isValidISBN13-1");
191         assertTrue(validator.isValidISBN13("978-1-930110-99-1"), "isValidISBN13-2");
192         assertTrue(validator.isValidISBN13("978 1 930110 99 1"), "isValidISBN13-3");
193         assertTrue(validator.isValidISBN13("9780201633856"), "isValidISBN13-4");
194         assertTrue(validator.isValidISBN13("978-0-201-63385-6"), "isValidISBN13-5");
195         assertTrue(validator.isValidISBN13("978 0 201 63385 6"), "isValidISBN13-6");
196 
197         assertTrue(validator.isValid("9781930110991"), "isValid-1");
198         assertTrue(validator.isValid("978-1-930110-99-1"), "isValid-2");
199         assertTrue(validator.isValid("978 1 930110 99 1"), "isValid-3");
200         assertTrue(validator.isValid("9780201633856"), "isValid-4");
201         assertTrue(validator.isValid("978-0-201-63385-6"), "isValid-5");
202         assertTrue(validator.isValid("978 0 201 63385 6"), "isValid-6");
203     }
204 
205     /**
206      * Test null values
207      */
208     @Test
209     void testNull() {
210         final ISBNValidator validator = ISBNValidator.getInstance();
211         assertFalse(validator.isValid(null), "isValid");
212         assertFalse(validator.isValidISBN10(null), "isValidISBN10");
213         assertFalse(validator.isValidISBN13(null), "isValidISBN13");
214         assertNull(validator.validate(null), "validate");
215         assertNull(validator.validateISBN10(null), "validateISBN10");
216         assertNull(validator.validateISBN13(null), "validateISBN13");
217         assertNull(validator.convertToISBN13(null), "convertToISBN13");
218     }
219 
220     /**
221      * Test validate() ISBN-10 codes (don't convert)
222      */
223     @Test
224     void testValidateISBN10() {
225         final ISBNValidator validator = ISBNValidator.getInstance(false);
226         assertEquals(validator.validateISBN10("1930110995"), "1930110995", "validateISBN10-1");
227         assertEquals(validator.validateISBN10("1-930110-99-5"), "1930110995", "validateISBN10-2");
228         assertEquals(validator.validateISBN10("1 930110 99 5"), "1930110995", "validateISBN10-3");
229         assertEquals(validator.validateISBN10("020163385X"), "020163385X", "validateISBN10-4");
230         assertEquals(validator.validateISBN10("0-201-63385-X"), "020163385X", "validateISBN10-5");
231         assertEquals(validator.validateISBN10("0 201 63385 X"), "020163385X", "validateISBN10-6");
232 
233         assertEquals(validator.validate("1930110995"), "1930110995", "validate-1");
234         assertEquals(validator.validate("1-930110-99-5"), "1930110995", "validate-2");
235         assertEquals(validator.validate("1 930110 99 5"), "1930110995", "validate-3");
236         assertEquals(validator.validate("020163385X"), "020163385X", "validate-4");
237         assertEquals(validator.validate("0-201-63385-X"), "020163385X", "validate-5");
238         assertEquals(validator.validate("0 201 63385 X"), "020163385X", "validate-6");
239     }
240 
241     /**
242      * Test validate() ISBN-10 codes (convert)
243      */
244     @Test
245     void testValidateISBN10Convert() {
246         final ISBNValidator validator = ISBNValidator.getInstance();
247         assertEquals(validator.validate("1930110995"), "9781930110991", "validate-1");
248         assertEquals(validator.validate("1-930110-99-5"), "9781930110991", "validate-2");
249         assertEquals(validator.validate("1 930110 99 5"), "9781930110991", "validate-3");
250         assertEquals(validator.validate("020163385X"), "9780201633856", "validate-4");
251         assertEquals(validator.validate("0-201-63385-X"), "9780201633856", "validate-5");
252         assertEquals(validator.validate("0 201 63385 X"), "9780201633856", "validate-6");
253     }
254 
255     /**
256      * Test validate() ISBN-13 codes
257      */
258     @Test
259     void testValidateISBN13() {
260         final ISBNValidator validator = ISBNValidator.getInstance();
261         assertEquals(validator.validateISBN13("9781930110991"), "9781930110991", "validateISBN13-1");
262         assertEquals(validator.validateISBN13("978-1-930110-99-1"), "9781930110991", "validateISBN13-2");
263         assertEquals(validator.validateISBN13("978 1 930110 99 1"), "9781930110991", "validateISBN13-3");
264         assertEquals(validator.validateISBN13("9780201633856"), "9780201633856", "validateISBN13-4");
265         assertEquals(validator.validateISBN13("978-0-201-63385-6"), "9780201633856", "validateISBN13-5");
266         assertEquals(validator.validateISBN13("978 0 201 63385 6"), "9780201633856", "validateISBN13-6");
267 
268         assertEquals(validator.validate("9781930110991"), "9781930110991", "validate-1");
269         assertEquals(validator.validate("978-1-930110-99-1"), "9781930110991", "validate-2");
270         assertEquals(validator.validate("978 1 930110 99 1"), "9781930110991", "validate-3");
271         assertEquals(validator.validate("9780201633856"), "9780201633856", "validate-4");
272         assertEquals(validator.validate("978-0-201-63385-6"), "9780201633856", "validate-5");
273         assertEquals(validator.validate("978 0 201 63385 6"), "9780201633856", "validate-6");
274     }
275 
276     /**
277      * Test Valid ISBN-10 formats.
278      */
279     @Test
280     void testValidISBN10Format() {
281         final Pattern pattern = Pattern.compile(ISBNValidator.ISBN10_REGEX);
282         for (int i = 0; i < validISBN10Format.length; i++) {
283             assertTrue(pattern.matcher(validISBN10Format[i]).matches(), "Pattern[" + i + "]=" + validISBN10Format[i]);
284         }
285     }
286 
287     /**
288      * Test Valid ISBN-13 formats.
289      */
290     @Test
291     void testValidISBN13Format() {
292         final Pattern pattern = Pattern.compile(ISBNValidator.ISBN13_REGEX);
293         for (int i = 0; i < validISBN13Format.length; i++) {
294             assertTrue(pattern.matcher(validISBN13Format[i]).matches(), "Pattern[" + i + "]=" + validISBN13Format[i]);
295         }
296     }
297 
298 }