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.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
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")
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 }