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 testIsAsciiPrintable_char() {
184 assertTrue(CharUtils.isAsciiPrintable('a'));
185 assertTrue(CharUtils.isAsciiPrintable('A'));
186 assertTrue(CharUtils.isAsciiPrintable('3'));
187 assertTrue(CharUtils.isAsciiPrintable('-'));
188 assertFalse(CharUtils.isAsciiPrintable('\n'));
189 assertFalse(CharUtils.isAsciiPrintable(CHAR_COPY));
190
191 for (int i = 0; i < 196; i++) {
192 if (i >= 32 && i <= 126) {
193 assertTrue(CharUtils.isAsciiPrintable((char) i));
194 } else {
195 assertFalse(CharUtils.isAsciiPrintable((char) i));
196 }
197 }
198 }
199
200 @Test
201 void testToChar_Character() {
202 assertEquals('A', CharUtils.toChar(CHARACTER_A));
203 assertEquals('B', CharUtils.toChar(CHARACTER_B));
204 assertNullPointerException(() -> CharUtils.toChar((Character) null));
205 }
206
207 @Test
208 void testToChar_Character_char() {
209 assertEquals('A', CharUtils.toChar(CHARACTER_A, 'X'));
210 assertEquals('B', CharUtils.toChar(CHARACTER_B, 'X'));
211 assertEquals('X', CharUtils.toChar((Character) null, 'X'));
212 }
213
214 @Test
215 void testToChar_String() {
216 assertEquals('A', CharUtils.toChar("A"));
217 assertEquals('B', CharUtils.toChar("BA"));
218 assertNullPointerException(() -> CharUtils.toChar((String) null));
219 assertIllegalArgumentException(() -> CharUtils.toChar(""));
220 }
221
222 @Test
223 void testToChar_String_char() {
224 assertEquals('A', CharUtils.toChar("A", 'X'));
225 assertEquals('B', CharUtils.toChar("BA", 'X'));
226 assertEquals('X', CharUtils.toChar("", 'X'));
227 assertEquals('X', CharUtils.toChar((String) null, 'X'));
228 }
229
230 @SuppressWarnings("deprecation")
231 @Test
232 void testToCharacterObject_char() {
233 assertEquals(Character.valueOf('a'), CharUtils.toCharacterObject('a'));
234 assertSame(CharUtils.toCharacterObject('a'), CharUtils.toCharacterObject('a'));
235
236 for (int i = 0; i < 128; i++) {
237 final Character ch = CharUtils.toCharacterObject((char) i);
238 final Character ch2 = CharUtils.toCharacterObject((char) i);
239 assertSame(ch, ch2);
240 assertEquals(i, ch.charValue());
241 }
242 for (int i = 128; i < 196; i++) {
243 final Character ch = CharUtils.toCharacterObject((char) i);
244 final Character ch2 = CharUtils.toCharacterObject((char) i);
245 assertEquals(ch, ch2);
246 assertNotSame(ch, ch2);
247 assertEquals(i, ch.charValue());
248 assertEquals(i, ch2.charValue());
249 }
250 assertSame(CharUtils.toCharacterObject("a"), CharUtils.toCharacterObject('a'));
251 }
252
253 @Test
254 void testToCharacterObject_String() {
255 assertNull(CharUtils.toCharacterObject(null));
256 assertNull(CharUtils.toCharacterObject(""));
257 assertEquals(Character.valueOf('a'), CharUtils.toCharacterObject("a"));
258 assertEquals(Character.valueOf('a'), CharUtils.toCharacterObject("abc"));
259 assertSame(CharUtils.toCharacterObject("a"), CharUtils.toCharacterObject("a"));
260 }
261
262 @Test
263 void testToIntValue_char() {
264 assertEquals(0, CharUtils.toIntValue('0'));
265 assertEquals(1, CharUtils.toIntValue('1'));
266 assertEquals(2, CharUtils.toIntValue('2'));
267 assertEquals(3, CharUtils.toIntValue('3'));
268 assertEquals(4, CharUtils.toIntValue('4'));
269 assertEquals(5, CharUtils.toIntValue('5'));
270 assertEquals(6, CharUtils.toIntValue('6'));
271 assertEquals(7, CharUtils.toIntValue('7'));
272 assertEquals(8, CharUtils.toIntValue('8'));
273 assertEquals(9, CharUtils.toIntValue('9'));
274 assertIllegalArgumentException(() -> CharUtils.toIntValue('a'));
275 }
276
277 @Test
278 void testToIntValue_char_int() {
279 assertEquals(0, CharUtils.toIntValue('0', -1));
280 assertEquals(3, CharUtils.toIntValue('3', -1));
281 assertEquals(-1, CharUtils.toIntValue('a', -1));
282 }
283
284 @Test
285 void testToIntValue_Character() {
286 assertEquals(0, CharUtils.toIntValue(Character.valueOf('0')));
287 assertEquals(3, CharUtils.toIntValue(Character.valueOf('3')));
288 assertNullPointerException(() -> CharUtils.toIntValue(null));
289 assertIllegalArgumentException(() -> CharUtils.toIntValue(CHARACTER_A));
290 }
291
292 @Test
293 void testToIntValue_Character_int() {
294 assertEquals(0, CharUtils.toIntValue(Character.valueOf('0'), -1));
295 assertEquals(3, CharUtils.toIntValue(Character.valueOf('3'), -1));
296 assertEquals(-1, CharUtils.toIntValue(Character.valueOf('A'), -1));
297 assertEquals(-1, CharUtils.toIntValue(null, -1));
298 }
299
300 @Test
301 void testToString_char() {
302 assertEquals("a", CharUtils.toString('a'));
303 assertSame(CharUtils.toString('a'), CharUtils.toString('a'));
304
305 for (int i = 0; i < 128; i++) {
306 final String str = CharUtils.toString((char) i);
307 final String str2 = CharUtils.toString((char) i);
308 assertSame(str, str2);
309 assertEquals(1, str.length());
310 assertEquals(i, str.charAt(0));
311 }
312 for (int i = 128; i < 196; i++) {
313 final String str = CharUtils.toString((char) i);
314 final String str2 = CharUtils.toString((char) i);
315 assertEquals(str, str2);
316 assertNotSame(str, str2);
317 assertEquals(1, str.length());
318 assertEquals(i, str.charAt(0));
319 assertEquals(1, str2.length());
320 assertEquals(i, str2.charAt(0));
321 }
322 }
323
324 @Test
325 void testToString_Character() {
326 assertNull(CharUtils.toString(null));
327 assertEquals("A", CharUtils.toString(CHARACTER_A));
328 assertSame(CharUtils.toString(CHARACTER_A), CharUtils.toString(CHARACTER_A));
329 }
330
331 @Test
332 void testToUnicodeEscaped_char() {
333 assertEquals("\\u0041", CharUtils.unicodeEscaped('A'));
334 assertEquals("\\u004c", CharUtils.unicodeEscaped('L'));
335
336 for (int i = 0; i < 196; i++) {
337 final String str = CharUtils.unicodeEscaped((char) i);
338 assertEquals(6, str.length());
339 final int val = Integer.parseInt(str.substring(2), 16);
340 assertEquals(i, val);
341 }
342 assertEquals("\\u0999", CharUtils.unicodeEscaped((char) 0x999));
343 assertEquals("\\u1001", CharUtils.unicodeEscaped((char) 0x1001));
344 }
345
346 @Test
347 void testToUnicodeEscaped_Character() {
348 assertNull(CharUtils.unicodeEscaped(null));
349 assertEquals("\\u0041", CharUtils.unicodeEscaped(CHARACTER_A));
350 }
351 }