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.lang3;
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.assertNotNull;
22  import static org.junit.jupiter.api.Assertions.assertNotSame;
23  import static org.junit.jupiter.api.Assertions.assertNull;
24  import static org.junit.jupiter.api.Assertions.assertSame;
25  import static org.junit.jupiter.api.Assertions.assertThrows;
26  import static org.junit.jupiter.api.Assertions.assertTrue;
27  
28  import java.lang.reflect.Constructor;
29  import java.lang.reflect.Modifier;
30  
31  import org.junit.jupiter.api.Test;
32  
33  /**
34   * Unit tests {@link org.apache.commons.lang3.CharUtils}.
35   */
36  public class CharUtilsTest extends AbstractLangTest {
37  
38      private static final char CHAR_COPY = '\u00a9';
39      private static final Character CHARACTER_A = Character.valueOf('A');
40      private static final Character CHARACTER_B = Character.valueOf('B');
41  
42      @Test
43      public void testCompare() {
44          assertTrue(CharUtils.compare('a', 'b') < 0);
45          assertEquals(0, CharUtils.compare('c', 'c'));
46          assertTrue(CharUtils.compare('c', 'a') > 0);
47      }
48  
49      @Test
50      public void testConstructor() {
51          assertNotNull(new CharUtils());
52          final Constructor<?>[] cons = CharUtils.class.getDeclaredConstructors();
53          assertEquals(1, cons.length);
54          assertTrue(Modifier.isPublic(cons[0].getModifiers()));
55          assertTrue(Modifier.isPublic(CharUtils.class.getModifiers()));
56          assertFalse(Modifier.isFinal(CharUtils.class.getModifiers()));
57      }
58  
59      @Test
60      public void testIsAscii_char() {
61          assertTrue(CharUtils.isAscii('a'));
62          assertTrue(CharUtils.isAscii('A'));
63          assertTrue(CharUtils.isAscii('3'));
64          assertTrue(CharUtils.isAscii('-'));
65          assertTrue(CharUtils.isAscii('\n'));
66          assertFalse(CharUtils.isAscii(CHAR_COPY));
67  
68          for (int i = 0; i < 255; i++) {
69              assertEquals(i < 128, CharUtils.isAscii((char) i));
70          }
71      }
72  
73      @Test
74      public void testIsAsciiAlpha_char() {
75          assertTrue(CharUtils.isAsciiAlpha('a'));
76          assertTrue(CharUtils.isAsciiAlpha('A'));
77          assertFalse(CharUtils.isAsciiAlpha('3'));
78          assertFalse(CharUtils.isAsciiAlpha('-'));
79          assertFalse(CharUtils.isAsciiAlpha('\n'));
80          assertFalse(CharUtils.isAsciiAlpha(CHAR_COPY));
81  
82          for (int i = 0; i < 196; i++) {
83              if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z')) {
84                  assertTrue(CharUtils.isAsciiAlpha((char) i));
85              } else {
86                  assertFalse(CharUtils.isAsciiAlpha((char) i));
87              }
88          }
89      }
90  
91      @Test
92      public void testIsAsciiAlphaLower_char() {
93          assertTrue(CharUtils.isAsciiAlphaLower('a'));
94          assertFalse(CharUtils.isAsciiAlphaLower('A'));
95          assertFalse(CharUtils.isAsciiAlphaLower('3'));
96          assertFalse(CharUtils.isAsciiAlphaLower('-'));
97          assertFalse(CharUtils.isAsciiAlphaLower('\n'));
98          assertFalse(CharUtils.isAsciiAlphaLower(CHAR_COPY));
99  
100         for (int i = 0; i < 196; i++) {
101             if (i >= 'a' && i <= 'z') {
102                 assertTrue(CharUtils.isAsciiAlphaLower((char) i));
103             } else {
104                 assertFalse(CharUtils.isAsciiAlphaLower((char) i));
105             }
106         }
107     }
108 
109     @Test
110     public void testIsAsciiAlphanumeric_char() {
111         assertTrue(CharUtils.isAsciiAlphanumeric('a'));
112         assertTrue(CharUtils.isAsciiAlphanumeric('A'));
113         assertTrue(CharUtils.isAsciiAlphanumeric('3'));
114         assertFalse(CharUtils.isAsciiAlphanumeric('-'));
115         assertFalse(CharUtils.isAsciiAlphanumeric('\n'));
116         assertFalse(CharUtils.isAsciiAlphanumeric(CHAR_COPY));
117 
118         for (int i = 0; i < 196; i++) {
119             if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || (i >= '0' && i <= '9')) {
120                 assertTrue(CharUtils.isAsciiAlphanumeric((char) i));
121             } else {
122                 assertFalse(CharUtils.isAsciiAlphanumeric((char) i));
123             }
124         }
125     }
126 
127     @Test
128     public void testIsAsciiAlphaUpper_char() {
129         assertFalse(CharUtils.isAsciiAlphaUpper('a'));
130         assertTrue(CharUtils.isAsciiAlphaUpper('A'));
131         assertFalse(CharUtils.isAsciiAlphaUpper('3'));
132         assertFalse(CharUtils.isAsciiAlphaUpper('-'));
133         assertFalse(CharUtils.isAsciiAlphaUpper('\n'));
134         assertFalse(CharUtils.isAsciiAlphaUpper(CHAR_COPY));
135 
136         for (int i = 0; i < 196; i++) {
137             if (i >= 'A' && i <= 'Z') {
138                 assertTrue(CharUtils.isAsciiAlphaUpper((char) i));
139             } else {
140                 assertFalse(CharUtils.isAsciiAlphaUpper((char) i));
141             }
142         }
143     }
144 
145     @Test
146     public void testIsAsciiControl_char() {
147         assertFalse(CharUtils.isAsciiControl('a'));
148         assertFalse(CharUtils.isAsciiControl('A'));
149         assertFalse(CharUtils.isAsciiControl('3'));
150         assertFalse(CharUtils.isAsciiControl('-'));
151         assertTrue(CharUtils.isAsciiControl('\n'));
152         assertFalse(CharUtils.isAsciiControl(CHAR_COPY));
153 
154         for (int i = 0; i < 196; i++) {
155             if (i < 32 || i == 127) {
156                 assertTrue(CharUtils.isAsciiControl((char) i));
157             } else {
158                 assertFalse(CharUtils.isAsciiControl((char) i));
159             }
160         }
161     }
162 
163     @Test
164     public void testIsAsciiNumeric_char() {
165         assertFalse(CharUtils.isAsciiNumeric('a'));
166         assertFalse(CharUtils.isAsciiNumeric('A'));
167         assertTrue(CharUtils.isAsciiNumeric('3'));
168         assertFalse(CharUtils.isAsciiNumeric('-'));
169         assertFalse(CharUtils.isAsciiNumeric('\n'));
170         assertFalse(CharUtils.isAsciiNumeric(CHAR_COPY));
171 
172         for (int i = 0; i < 196; i++) {
173             if (i >= '0' && i <= '9') {
174                 assertTrue(CharUtils.isAsciiNumeric((char) i));
175             } else {
176                 assertFalse(CharUtils.isAsciiNumeric((char) i));
177             }
178         }
179     }
180 
181     @Test
182     public void testIsAsciiPrintable_char() {
183         assertTrue(CharUtils.isAsciiPrintable('a'));
184         assertTrue(CharUtils.isAsciiPrintable('A'));
185         assertTrue(CharUtils.isAsciiPrintable('3'));
186         assertTrue(CharUtils.isAsciiPrintable('-'));
187         assertFalse(CharUtils.isAsciiPrintable('\n'));
188         assertFalse(CharUtils.isAsciiPrintable(CHAR_COPY));
189 
190         for (int i = 0; i < 196; i++) {
191             if (i >= 32 && i <= 126) {
192                 assertTrue(CharUtils.isAsciiPrintable((char) i));
193             } else {
194                 assertFalse(CharUtils.isAsciiPrintable((char) i));
195             }
196         }
197     }
198 
199     @Test
200     public void testToChar_Character() {
201         assertEquals('A', CharUtils.toChar(CHARACTER_A));
202         assertEquals('B', CharUtils.toChar(CHARACTER_B));
203         assertThrows(NullPointerException.class, () -> CharUtils.toChar((Character) null));
204     }
205 
206     @Test
207     public void testToChar_Character_char() {
208         assertEquals('A', CharUtils.toChar(CHARACTER_A, 'X'));
209         assertEquals('B', CharUtils.toChar(CHARACTER_B, 'X'));
210         assertEquals('X', CharUtils.toChar((Character) null, 'X'));
211     }
212 
213     @Test
214     public void testToChar_String() {
215         assertEquals('A', CharUtils.toChar("A"));
216         assertEquals('B', CharUtils.toChar("BA"));
217         assertThrows(NullPointerException.class, () -> CharUtils.toChar((String) null));
218         assertThrows(IllegalArgumentException.class, () -> CharUtils.toChar(""));
219     }
220 
221     @Test
222     public void testToChar_String_char() {
223         assertEquals('A', CharUtils.toChar("A", 'X'));
224         assertEquals('B', CharUtils.toChar("BA", 'X'));
225         assertEquals('X', CharUtils.toChar("", 'X'));
226         assertEquals('X', CharUtils.toChar((String) null, 'X'));
227     }
228 
229     @SuppressWarnings("deprecation") // intentional test of deprecated method
230     @Test
231     public void testToCharacterObject_char() {
232         assertEquals(Character.valueOf('a'), CharUtils.toCharacterObject('a'));
233         assertSame(CharUtils.toCharacterObject('a'), CharUtils.toCharacterObject('a'));
234 
235         for (int i = 0; i < 128; i++) {
236             final Character ch = CharUtils.toCharacterObject((char) i);
237             final Character ch2 = CharUtils.toCharacterObject((char) i);
238             assertSame(ch, ch2);
239             assertEquals(i, ch.charValue());
240         }
241         for (int i = 128; i < 196; i++) {
242             final Character ch = CharUtils.toCharacterObject((char) i);
243             final Character ch2 = CharUtils.toCharacterObject((char) i);
244             assertEquals(ch, ch2);
245             assertNotSame(ch, ch2);
246             assertEquals(i, ch.charValue());
247             assertEquals(i, ch2.charValue());
248         }
249         assertSame(CharUtils.toCharacterObject("a"), CharUtils.toCharacterObject('a'));
250     }
251 
252     @Test
253     public void testToCharacterObject_String() {
254         assertNull(CharUtils.toCharacterObject(null));
255         assertNull(CharUtils.toCharacterObject(""));
256         assertEquals(Character.valueOf('a'), CharUtils.toCharacterObject("a"));
257         assertEquals(Character.valueOf('a'), CharUtils.toCharacterObject("abc"));
258         assertSame(CharUtils.toCharacterObject("a"), CharUtils.toCharacterObject("a"));
259     }
260 
261     @Test
262     public void testToIntValue_char() {
263         assertEquals(0, CharUtils.toIntValue('0'));
264         assertEquals(1, CharUtils.toIntValue('1'));
265         assertEquals(2, CharUtils.toIntValue('2'));
266         assertEquals(3, CharUtils.toIntValue('3'));
267         assertEquals(4, CharUtils.toIntValue('4'));
268         assertEquals(5, CharUtils.toIntValue('5'));
269         assertEquals(6, CharUtils.toIntValue('6'));
270         assertEquals(7, CharUtils.toIntValue('7'));
271         assertEquals(8, CharUtils.toIntValue('8'));
272         assertEquals(9, CharUtils.toIntValue('9'));
273         assertThrows(IllegalArgumentException.class, () -> CharUtils.toIntValue('a'));
274     }
275 
276     @Test
277     public void testToIntValue_char_int() {
278         assertEquals(0, CharUtils.toIntValue('0', -1));
279         assertEquals(3, CharUtils.toIntValue('3', -1));
280         assertEquals(-1, CharUtils.toIntValue('a', -1));
281     }
282 
283     @Test
284     public void testToIntValue_Character() {
285         assertEquals(0, CharUtils.toIntValue(Character.valueOf('0')));
286         assertEquals(3, CharUtils.toIntValue(Character.valueOf('3')));
287         assertThrows(NullPointerException.class, () -> CharUtils.toIntValue(null));
288         assertThrows(IllegalArgumentException.class, () -> CharUtils.toIntValue(CHARACTER_A));
289     }
290 
291     @Test
292     public void testToIntValue_Character_int() {
293         assertEquals(0, CharUtils.toIntValue(Character.valueOf('0'), -1));
294         assertEquals(3, CharUtils.toIntValue(Character.valueOf('3'), -1));
295         assertEquals(-1, CharUtils.toIntValue(Character.valueOf('A'), -1));
296         assertEquals(-1, CharUtils.toIntValue(null, -1));
297     }
298 
299     @Test
300     public void testToString_char() {
301         assertEquals("a", CharUtils.toString('a'));
302         assertSame(CharUtils.toString('a'), CharUtils.toString('a'));
303 
304         for (int i = 0; i < 128; i++) {
305             final String str = CharUtils.toString((char) i);
306             final String str2 = CharUtils.toString((char) i);
307             assertSame(str, str2);
308             assertEquals(1, str.length());
309             assertEquals(i, str.charAt(0));
310         }
311         for (int i = 128; i < 196; i++) {
312             final String str = CharUtils.toString((char) i);
313             final String str2 = CharUtils.toString((char) i);
314             assertEquals(str, str2);
315             assertNotSame(str, str2);
316             assertEquals(1, str.length());
317             assertEquals(i, str.charAt(0));
318             assertEquals(1, str2.length());
319             assertEquals(i, str2.charAt(0));
320         }
321     }
322 
323     @Test
324     public void testToString_Character() {
325         assertNull(CharUtils.toString(null));
326         assertEquals("A", CharUtils.toString(CHARACTER_A));
327         assertSame(CharUtils.toString(CHARACTER_A), CharUtils.toString(CHARACTER_A));
328     }
329 
330     @Test
331     public void testToUnicodeEscaped_char() {
332         assertEquals("\\u0041", CharUtils.unicodeEscaped('A'));
333         assertEquals("\\u004c", CharUtils.unicodeEscaped('L'));
334 
335         for (int i = 0; i < 196; i++) {
336             final String str = CharUtils.unicodeEscaped((char) i);
337             assertEquals(6, str.length());
338             final int val = Integer.parseInt(str.substring(2), 16);
339             assertEquals(i, val);
340         }
341         assertEquals("\\u0999", CharUtils.unicodeEscaped((char) 0x999));
342         assertEquals("\\u1001", CharUtils.unicodeEscaped((char) 0x1001));
343     }
344 
345     @Test
346     public void testToUnicodeEscaped_Character() {
347         assertNull(CharUtils.unicodeEscaped(null));
348         assertEquals("\\u0041", CharUtils.unicodeEscaped(CHARACTER_A));
349     }
350 }