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