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.io;
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.assertNotSame;
22  import static org.junit.jupiter.api.Assertions.assertSame;
23  import static org.junit.jupiter.api.Assertions.assertThrows;
24  import static org.junit.jupiter.api.Assertions.assertTrue;
25  
26  import java.io.ByteArrayInputStream;
27  import java.io.ByteArrayOutputStream;
28  import java.io.File;
29  import java.io.ObjectInputStream;
30  import java.io.ObjectOutputStream;
31  import java.util.Arrays;
32  
33  import org.apache.commons.io.IOUtils.ScratchBytes;
34  import org.apache.commons.io.IOUtils.ScratchChars;
35  import org.junit.jupiter.api.Test;
36  
37  /**
38   * Tests {@link IOCase}.
39   */
40  class IOCaseTest {
41  
42      private static final boolean WINDOWS = File.separatorChar == '\\';
43  
44      private void assert0(final byte[] arr) {
45          for (final byte e : arr) {
46              assertEquals(0, e);
47          }
48      }
49  
50      private void assert0(final char[] arr) {
51          for (final char e : arr) {
52              assertEquals(0, e);
53          }
54      }
55  
56      private IOCase serialize(final IOCase value) throws Exception {
57          final ByteArrayOutputStream buf = new ByteArrayOutputStream();
58          try (ObjectOutputStream out = new ObjectOutputStream(buf)) {
59              out.writeObject(value);
60              out.flush();
61          }
62  
63          final ByteArrayInputStream bufin = new ByteArrayInputStream(buf.toByteArray());
64          final ObjectInputStream in = new ObjectInputStream(bufin);
65          return (IOCase) in.readObject();
66      }
67  
68      @Test
69      void test_checkCompare_case() {
70          assertEquals(0, IOCase.SENSITIVE.checkCompareTo("ABC", "ABC"));
71          assertTrue(IOCase.SENSITIVE.checkCompareTo("ABC", "abc") < 0);
72          assertTrue(IOCase.SENSITIVE.checkCompareTo("abc", "ABC") > 0);
73  
74          assertEquals(0, IOCase.INSENSITIVE.checkCompareTo("ABC", "ABC"));
75          assertEquals(0, IOCase.INSENSITIVE.checkCompareTo("ABC", "abc"));
76          assertEquals(0, IOCase.INSENSITIVE.checkCompareTo("abc", "ABC"));
77  
78          assertEquals(0, IOCase.SYSTEM.checkCompareTo("ABC", "ABC"));
79          assertEquals(WINDOWS, IOCase.SYSTEM.checkCompareTo("ABC", "abc") == 0);
80          assertEquals(WINDOWS, IOCase.SYSTEM.checkCompareTo("abc", "ABC") == 0);
81      }
82  
83      @Test
84      void test_checkCompare_functionality() {
85          assertTrue(IOCase.SENSITIVE.checkCompareTo("ABC", "") > 0);
86          assertTrue(IOCase.SENSITIVE.checkCompareTo("", "ABC") < 0);
87          assertTrue(IOCase.SENSITIVE.checkCompareTo("ABC", "DEF") < 0);
88          assertTrue(IOCase.SENSITIVE.checkCompareTo("DEF", "ABC") > 0);
89          assertEquals(0, IOCase.SENSITIVE.checkCompareTo("ABC", "ABC"));
90          assertEquals(0, IOCase.SENSITIVE.checkCompareTo("", ""));
91  
92          assertThrows(NullPointerException.class, () -> IOCase.SENSITIVE.checkCompareTo("ABC", null));
93          assertThrows(NullPointerException.class, () -> IOCase.SENSITIVE.checkCompareTo(null, "ABC"));
94          assertThrows(NullPointerException.class, () -> IOCase.SENSITIVE.checkCompareTo(null, null));
95      }
96      @Test
97      void test_checkEndsWith_case() {
98          assertTrue(IOCase.SENSITIVE.checkEndsWith("ABC", "BC"));
99          assertFalse(IOCase.SENSITIVE.checkEndsWith("ABC", "Bc"));
100 
101         assertTrue(IOCase.INSENSITIVE.checkEndsWith("ABC", "BC"));
102         assertTrue(IOCase.INSENSITIVE.checkEndsWith("ABC", "Bc"));
103 
104         assertTrue(IOCase.SYSTEM.checkEndsWith("ABC", "BC"));
105         assertEquals(WINDOWS, IOCase.SYSTEM.checkEndsWith("ABC", "Bc"));
106     }
107 
108     @Test
109     void test_checkEndsWith_functionality() {
110         assertTrue(IOCase.SENSITIVE.checkEndsWith("ABC", ""));
111         assertFalse(IOCase.SENSITIVE.checkEndsWith("ABC", "A"));
112         assertFalse(IOCase.SENSITIVE.checkEndsWith("ABC", "AB"));
113         assertTrue(IOCase.SENSITIVE.checkEndsWith("ABC", "ABC"));
114         assertTrue(IOCase.SENSITIVE.checkEndsWith("ABC", "BC"));
115         assertTrue(IOCase.SENSITIVE.checkEndsWith("ABC", "C"));
116         assertFalse(IOCase.SENSITIVE.checkEndsWith("ABC", "ABCD"));
117         assertFalse(IOCase.SENSITIVE.checkEndsWith("", "ABC"));
118         assertTrue(IOCase.SENSITIVE.checkEndsWith("", ""));
119 
120         assertFalse(IOCase.SENSITIVE.checkEndsWith("ABC", null));
121         assertFalse(IOCase.SENSITIVE.checkEndsWith(null, "ABC"));
122         assertFalse(IOCase.SENSITIVE.checkEndsWith(null, null));
123     }
124 
125     @Test
126     void test_checkEquals_case() {
127         assertTrue(IOCase.SENSITIVE.checkEquals("ABC", "ABC"));
128         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", "Abc"));
129 
130         assertTrue(IOCase.INSENSITIVE.checkEquals("ABC", "ABC"));
131         assertTrue(IOCase.INSENSITIVE.checkEquals("ABC", "Abc"));
132 
133         assertTrue(IOCase.SYSTEM.checkEquals("ABC", "ABC"));
134         assertEquals(WINDOWS, IOCase.SYSTEM.checkEquals("ABC", "Abc"));
135     }
136 
137     @Test
138     void test_checkEquals_functionality() {
139         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", ""));
140         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", "A"));
141         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", "AB"));
142         assertTrue(IOCase.SENSITIVE.checkEquals("ABC", "ABC"));
143         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", "BC"));
144         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", "C"));
145         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", "ABCD"));
146         assertFalse(IOCase.SENSITIVE.checkEquals("", "ABC"));
147         assertTrue(IOCase.SENSITIVE.checkEquals("", ""));
148 
149         assertFalse(IOCase.SENSITIVE.checkEquals("ABC", null));
150         assertFalse(IOCase.SENSITIVE.checkEquals(null, "ABC"));
151         assertTrue(IOCase.SENSITIVE.checkEquals(null, null));
152     }
153 
154     @Test
155     void test_checkIndexOf_case() {
156         assertEquals(1,  IOCase.SENSITIVE.checkIndexOf("ABC", 0, "BC"));
157         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf("ABC", 0, "Bc"));
158         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf(null, 0, "Bc"));
159         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf(null, 0, null));
160         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf("ABC", 0, null));
161 
162         assertEquals(1, IOCase.INSENSITIVE.checkIndexOf("ABC", 0, "BC"));
163         assertEquals(1, IOCase.INSENSITIVE.checkIndexOf("ABC", 0, "Bc"));
164 
165         assertEquals(1, IOCase.SYSTEM.checkIndexOf("ABC", 0, "BC"));
166         assertEquals(WINDOWS ? 1 : -1, IOCase.SYSTEM.checkIndexOf("ABC", 0, "Bc"));
167     }
168 
169     @Test
170     void test_checkIndexOf_functionality() {
171 
172         // start
173         assertEquals(0,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "A"));
174         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 1, "A"));
175         assertEquals(0,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "AB"));
176         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 1, "AB"));
177         assertEquals(0,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "ABC"));
178         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 1, "ABC"));
179 
180         // middle
181         assertEquals(3,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "D"));
182         assertEquals(3,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 3, "D"));
183         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 4, "D"));
184         assertEquals(3,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "DE"));
185         assertEquals(3,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 3, "DE"));
186         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 4, "DE"));
187         assertEquals(3,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "DEF"));
188         assertEquals(3,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 3, "DEF"));
189         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 4, "DEF"));
190 
191         // end
192         assertEquals(9,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "J"));
193         assertEquals(9,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 8, "J"));
194         assertEquals(9,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 9, "J"));
195         assertEquals(8,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "IJ"));
196         assertEquals(8,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 8, "IJ"));
197         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 9, "IJ"));
198         assertEquals(7,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 6, "HIJ"));
199         assertEquals(7,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 7, "HIJ"));
200         assertEquals(-1,  IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 8, "HIJ"));
201 
202         // not found
203         assertEquals(-1,   IOCase.SENSITIVE.checkIndexOf("ABCDEFGHIJ", 0, "DED"));
204 
205         // too long
206         assertEquals(-1,   IOCase.SENSITIVE.checkIndexOf("DEF", 0, "ABCDEFGHIJ"));
207 
208         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf("ABC", 0, null));
209         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf(null, 0, "ABC"));
210         assertEquals(-1, IOCase.SENSITIVE.checkIndexOf(null, 0, null));
211     }
212 
213     @Test
214     void test_checkRegionMatches_case() {
215         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "AB"));
216         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "Ab"));
217 
218         assertTrue(IOCase.INSENSITIVE.checkRegionMatches("ABC", 0, "AB"));
219         assertTrue(IOCase.INSENSITIVE.checkRegionMatches("ABC", 0, "Ab"));
220 
221         assertTrue(IOCase.SYSTEM.checkRegionMatches("ABC", 0, "AB"));
222         assertEquals(WINDOWS, IOCase.SYSTEM.checkRegionMatches("ABC", 0, "Ab"));
223     }
224 
225     @Test
226     void test_checkRegionMatches_functionality() {
227         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, ""));
228         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "A"));
229         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "AB"));
230         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "ABC"));
231         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "BC"));
232         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "C"));
233         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, "ABCD"));
234         assertFalse(IOCase.SENSITIVE.checkRegionMatches("", 0, "ABC"));
235         assertTrue(IOCase.SENSITIVE.checkRegionMatches("", 0, ""));
236 
237         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, ""));
238         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, "A"));
239         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, "AB"));
240         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, "ABC"));
241         assertTrue(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, "BC"));
242         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, "C"));
243         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, "ABCD"));
244         assertFalse(IOCase.SENSITIVE.checkRegionMatches("", 1, "ABC"));
245         assertFalse(IOCase.SENSITIVE.checkRegionMatches("", 1, ""));
246 
247         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 0, null));
248         assertFalse(IOCase.SENSITIVE.checkRegionMatches(null, 0, "ABC"));
249         assertFalse(IOCase.SENSITIVE.checkRegionMatches(null, 0, null));
250         assertFalse(IOCase.SENSITIVE.checkRegionMatches("ABC", 1, null));
251         assertFalse(IOCase.SENSITIVE.checkRegionMatches(null, 1, "ABC"));
252         assertFalse(IOCase.SENSITIVE.checkRegionMatches(null, 1, null));
253     }
254 
255     @Test
256     void test_checkStartsWith_case() {
257         assertTrue(IOCase.SENSITIVE.checkStartsWith("ABC", "AB"));
258         assertFalse(IOCase.SENSITIVE.checkStartsWith("ABC", "Ab"));
259 
260         assertTrue(IOCase.INSENSITIVE.checkStartsWith("ABC", "AB"));
261         assertTrue(IOCase.INSENSITIVE.checkStartsWith("ABC", "Ab"));
262 
263         assertTrue(IOCase.SYSTEM.checkStartsWith("ABC", "AB"));
264         assertEquals(WINDOWS, IOCase.SYSTEM.checkStartsWith("ABC", "Ab"));
265     }
266 
267     @Test
268     void test_checkStartsWith_functionality() {
269         assertTrue(IOCase.SENSITIVE.checkStartsWith("ABC", ""));
270         assertTrue(IOCase.SENSITIVE.checkStartsWith("ABC", "A"));
271         assertTrue(IOCase.SENSITIVE.checkStartsWith("ABC", "AB"));
272         assertTrue(IOCase.SENSITIVE.checkStartsWith("ABC", "ABC"));
273         assertFalse(IOCase.SENSITIVE.checkStartsWith("ABC", "BC"));
274         assertFalse(IOCase.SENSITIVE.checkStartsWith("ABC", "C"));
275         assertFalse(IOCase.SENSITIVE.checkStartsWith("ABC", "ABCD"));
276         assertFalse(IOCase.SENSITIVE.checkStartsWith("", "ABC"));
277         assertTrue(IOCase.SENSITIVE.checkStartsWith("", ""));
278 
279         assertFalse(IOCase.SENSITIVE.checkStartsWith("ABC", null));
280         assertFalse(IOCase.SENSITIVE.checkStartsWith(null, "ABC"));
281         assertFalse(IOCase.SENSITIVE.checkStartsWith(null, null));
282     }
283 
284     @Test
285     void test_forName() {
286         assertEquals(IOCase.SENSITIVE, IOCase.forName("Sensitive"));
287         assertEquals(IOCase.INSENSITIVE, IOCase.forName("Insensitive"));
288         assertEquals(IOCase.SYSTEM, IOCase.forName("System"));
289         assertThrows(IllegalArgumentException.class, () -> IOCase.forName("Blah"));
290         assertThrows(IllegalArgumentException.class, () -> IOCase.forName(null));
291     }
292 
293     @Test
294     void test_getName() {
295         assertEquals("Sensitive", IOCase.SENSITIVE.getName());
296         assertEquals("Insensitive", IOCase.INSENSITIVE.getName());
297         assertEquals("System", IOCase.SYSTEM.getName());
298     }
299 
300     @Test
301     void test_getScratchByteArray() {
302         final byte[] array;
303         try (ScratchBytes scratch = IOUtils.ScratchBytes.get()) {
304             array = scratch.array();
305             assert0(array);
306             Arrays.fill(array, (byte) 1);
307             // Get another array, while the first is still in use
308             // The test doesn't need the try here but that's the pattern.
309             try (ScratchBytes scratch2 = IOUtils.ScratchBytes.get()) {
310                 assertNotSame(scratch, scratch2);
311                 final byte[] array2 = scratch2.array();
312                 assert0(array2);
313                 assertNotSame(array, array2);
314             }
315         }
316         // The first array should be reset and reusable
317         try (ScratchBytes scratch = IOUtils.ScratchBytes.get()) {
318             final byte[] array3 = scratch.array();
319             assert0(array3);
320             assertSame(array, array3);
321         }
322     }
323 
324     @Test
325     void test_getScratchCharArray() {
326         final char[] array;
327         try (ScratchChars scratch = IOUtils.ScratchChars.get()) {
328             array = scratch.array();
329             assert0(array);
330             Arrays.fill(array, (char) 1);
331             // Get another array, while the first is still in use
332             // The test doesn't need the try here but that's the pattern.
333             try (ScratchChars scratch2 = IOUtils.ScratchChars.get()) {
334                 final char[] array2 = scratch2.array();
335                 assert0(array2);
336                 assertNotSame(array, array2);
337             }
338         }
339         // The first array should be reset and reusable
340         try (ScratchChars scratch = IOUtils.ScratchChars.get()) {
341             final char[] array3 = scratch.array();
342             assert0(array3);
343             assertSame(array, array3);
344         }
345     }
346 
347     @Test
348     void test_isCaseSensitive() {
349         assertTrue(IOCase.SENSITIVE.isCaseSensitive());
350         assertFalse(IOCase.INSENSITIVE.isCaseSensitive());
351         assertEquals(!WINDOWS, IOCase.SYSTEM.isCaseSensitive());
352     }
353 
354     @Test
355     void test_isCaseSensitive_static() {
356         assertTrue(IOCase.isCaseSensitive(IOCase.SENSITIVE));
357         assertFalse(IOCase.isCaseSensitive(IOCase.INSENSITIVE));
358         assertEquals(!WINDOWS, IOCase.isCaseSensitive(IOCase.SYSTEM));
359     }
360 
361     @Test
362     void test_serialization() throws Exception {
363         assertSame(IOCase.SENSITIVE, serialize(IOCase.SENSITIVE));
364         assertSame(IOCase.INSENSITIVE, serialize(IOCase.INSENSITIVE));
365         assertSame(IOCase.SYSTEM, serialize(IOCase.SYSTEM));
366     }
367 
368     @Test
369     void test_toString() {
370         assertEquals("Sensitive", IOCase.SENSITIVE.toString());
371         assertEquals("Insensitive", IOCase.INSENSITIVE.toString());
372         assertEquals("System", IOCase.SYSTEM.toString());
373     }
374 
375 }