1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.juneau.commons.utils;
18
19 import static org.apache.juneau.TestUtils.*;
20 import static org.apache.juneau.commons.utils.CollectionUtils.*;
21 import static org.apache.juneau.commons.utils.IoUtils.*;
22 import static org.apache.juneau.commons.utils.StringUtils.*;
23 import static org.apache.juneau.junit.bct.BctAssertions.*;
24 import static org.junit.jupiter.api.Assertions.*;
25
26 import java.io.*;
27 import java.math.*;
28 import java.util.concurrent.atomic.*;
29 import java.util.*;
30
31 import org.apache.juneau.*;
32 import org.apache.juneau.commons.lang.*;
33 import org.junit.jupiter.api.*;
34
35 class StringUtils_Test extends TestBase {
36
37 @SuppressWarnings("serial")
38 private abstract static class BadNumber extends Number {}
39
40
41
42
43 @Test
44 void a00_constructor() {
45
46
47 var instance = new StringUtils();
48 assertNotNull(instance);
49 }
50
51
52
53
54 @Test
55 void a001_abbreviate() {
56
57 assertNull(abbreviate(null, 10));
58
59
60 assertEquals("", abbreviate("", 10));
61 assertEquals("Hi", abbreviate("Hi", 10));
62 assertEquals("Hello", abbreviate("Hello", 10));
63 assertEquals("Hello World", abbreviate("Hello World", 20));
64
65
66 assertEquals("Hi", abbreviate("Hi", 5));
67 assertEquals("ABC", abbreviate("ABC", 5));
68
69
70 assertEquals("Hello...", abbreviate("Hello World", 8));
71 assertEquals("H...", abbreviate("Hello", 4));
72
73 assertEquals("Hello", abbreviate("Hello", 5));
74 assertEquals("Hello", abbreviate("Hello", 6));
75 assertEquals("Hello", abbreviate("Hello", 7));
76
77
78 assertEquals("H...", abbreviate("Hello", 4));
79
80
81 assertEquals("ABC", abbreviate("ABC", 2));
82 assertEquals("ABC", abbreviate("ABC", 3));
83 assertEquals("ABC", abbreviate("ABC", 4));
84 assertEquals("ABC", abbreviate("ABC", 10));
85
86
87 assertEquals("AB", abbreviate("AB", 1));
88 assertEquals("AB", abbreviate("AB", 2));
89
90
91 assertEquals("A", abbreviate("A", 1));
92 }
93
94
95
96
97 @Test
98 void a002_append() {
99 var sb = new StringBuilder();
100 assertSame(sb, append(sb, "test"));
101 assertEquals("test", sb.toString());
102
103 assertSame(sb, append(sb, "more"));
104 assertEquals("testmore", sb.toString());
105
106
107 var result = append(null, "test");
108 assertNotNull(result);
109 assertEquals("test", result.toString());
110
111
112 var sb2 = new StringBuilder("prefix");
113 assertSame(sb2, append(sb2, null));
114 assertEquals("prefixnull", sb2.toString());
115 }
116
117
118
119
120 @Test
121 void a003_appendIfNotBlank() {
122 var sb = new StringBuilder();
123 assertSame(sb, appendIfNotBlank(sb, "hello"));
124 assertEquals("hello", sb.toString());
125
126
127 appendIfNotBlank(sb, " ");
128 assertEquals("hello", sb.toString());
129
130 appendIfNotBlank(sb, "\t\n");
131 assertEquals("hello", sb.toString());
132
133 appendIfNotBlank(sb, "");
134 assertEquals("hello", sb.toString());
135
136 appendIfNotBlank(sb, null);
137 assertEquals("hello", sb.toString());
138
139
140 appendIfNotBlank(sb, "world");
141 assertEquals("helloworld", sb.toString());
142
143 var sb2 = new StringBuilder("prefix");
144 appendIfNotBlank(sb2, "suffix");
145 assertEquals("prefixsuffix", sb2.toString());
146
147
148 var sb3 = appendIfNotBlank(null, "test");
149 assertNotNull(sb3);
150 assertEquals("test", sb3.toString());
151
152
153 assertNull(appendIfNotBlank(null, null));
154 assertNull(appendIfNotBlank(null, ""));
155 assertNull(appendIfNotBlank(null, " "));
156 assertNull(appendIfNotBlank(null, "\t\n"));
157 }
158
159
160
161
162 @Test
163 void a004_appendIfNotEmpty() {
164 var sb = new StringBuilder();
165 assertSame(sb, appendIfNotEmpty(sb, "hello"));
166 assertEquals("hello", sb.toString());
167
168
169 appendIfNotEmpty(sb, "");
170 assertEquals("hello", sb.toString());
171
172 appendIfNotEmpty(sb, null);
173 assertEquals("hello", sb.toString());
174
175
176 appendIfNotEmpty(sb, "world");
177 assertEquals("helloworld", sb.toString());
178
179 var sb2 = new StringBuilder("prefix");
180 appendIfNotEmpty(sb2, "suffix");
181 assertEquals("prefixsuffix", sb2.toString());
182
183
184 var sb3 = appendIfNotEmpty(null, "test");
185 assertNotNull(sb3);
186 assertEquals("test", sb3.toString());
187
188
189 assertNull(appendIfNotEmpty(null, null));
190 assertNull(appendIfNotEmpty(null, ""));
191 }
192
193
194
195
196 @Test
197 void a005_appendWithSeparator() {
198 var sb = new StringBuilder();
199 assertSame(sb, appendWithSeparator(sb, "first", ", "));
200 assertEquals("first", sb.toString());
201
202
203 appendWithSeparator(sb, "second", ", ");
204 assertEquals("first, second", sb.toString());
205
206 appendWithSeparator(sb, "third", ", ");
207 assertEquals("first, second, third", sb.toString());
208
209 var sb2 = new StringBuilder();
210 appendWithSeparator(sb2, "a", "-");
211 appendWithSeparator(sb2, "b", "-");
212 appendWithSeparator(sb2, "c", "-");
213 assertEquals("a-b-c", sb2.toString());
214
215 var sb3 = new StringBuilder();
216 appendWithSeparator(sb3, "x", null);
217 assertEquals("x", sb3.toString());
218 appendWithSeparator(sb3, "y", null);
219 assertEquals("xy", sb3.toString());
220
221 var sb4 = new StringBuilder();
222 appendWithSeparator(sb4, null, ", ");
223 assertEquals("", sb4.toString());
224 appendWithSeparator(sb4, "test", ", ");
225 assertEquals("test", sb4.toString());
226
227
228 var sb5 = appendWithSeparator(null, "test", ", ");
229 assertNotNull(sb5);
230 assertEquals("test", sb5.toString());
231
232 var sb6 = appendWithSeparator(null, "first", ", ");
233 appendWithSeparator(sb6, "second", ", ");
234 assertEquals("first, second", sb6.toString());
235
236
237 assertNull(appendWithSeparator(null, null, ", "));
238 }
239
240
241
242
243 @Test
244 void a006_articlized() {
245 assertEquals("an apple", articlized("apple"));
246 assertEquals("an Apple", articlized("Apple"));
247 assertEquals("a banana", articlized("banana"));
248 assertEquals("a Banana", articlized("Banana"));
249 assertEquals("an elephant", articlized("elephant"));
250 assertEquals("an island", articlized("island"));
251 assertEquals("an orange", articlized("orange"));
252 assertEquals("an umbrella", articlized("umbrella"));
253 }
254
255
256
257
258 @Test
259 void a007_base64Decode() {
260 assertNull(base64Decode(null));
261 assertArrayEquals(new byte[] {}, base64Decode(""));
262 assertArrayEquals("Hello".getBytes(UTF8), base64Decode("SGVsbG8="));
263 assertArrayEquals("Hello World".getBytes(UTF8), base64Decode("SGVsbG8gV29ybGQ="));
264 assertArrayEquals("A".getBytes(UTF8), base64Decode("QQ=="));
265 assertArrayEquals("AB".getBytes(UTF8), base64Decode("QUI="));
266 assertArrayEquals("ABC".getBytes(UTF8), base64Decode("QUJD"));
267 assertArrayEquals(new byte[] { 0x00, 0x01, 0x02 }, base64Decode("AAEC"));
268 assertArrayEquals(new byte[] { (byte)0xFF, (byte)0xFE, (byte)0xFD }, base64Decode("//79"));
269
270
271 assertThrows(IllegalArgumentException.class, () -> base64Decode("A"));
272 assertThrows(IllegalArgumentException.class, () -> base64Decode("AB"));
273 assertThrows(IllegalArgumentException.class, () -> base64Decode("ABC"));
274 assertThrows(IllegalArgumentException.class, () -> base64Decode("ABCDE"));
275 assertThrows(IllegalArgumentException.class, () -> base64Decode("ABCDEF"));
276 assertThrows(IllegalArgumentException.class, () -> base64Decode("ABCDEFG"));
277 }
278
279
280
281
282 @Test
283 void a008_base64DecodeToString() {
284 assertNull(base64DecodeToString(null));
285 assertEquals("", base64DecodeToString(""));
286 assertEquals("Hello", base64DecodeToString("SGVsbG8="));
287 assertEquals("Hello World", base64DecodeToString("SGVsbG8gV29ybGQ="));
288 assertEquals("A", base64DecodeToString("QQ=="));
289 assertEquals("AB", base64DecodeToString("QUI="));
290 assertEquals("ABC", base64DecodeToString("QUJD"));
291 assertEquals("test\nline", base64DecodeToString("dGVzdApsaW5l"));
292 }
293
294
295
296
297 @Test
298 void a009_base64Encode() {
299 assertNull(base64Encode(null));
300 assertEquals("", base64Encode(new byte[] {}));
301 assertEquals("SGVsbG8=", base64Encode("Hello".getBytes(UTF8)));
302 assertEquals("SGVsbG8gV29ybGQ=", base64Encode("Hello World".getBytes(UTF8)));
303 assertEquals("QQ==", base64Encode("A".getBytes(UTF8)));
304 assertEquals("QUI=", base64Encode("AB".getBytes(UTF8)));
305 assertEquals("QUJD", base64Encode("ABC".getBytes(UTF8)));
306 assertEquals("AAEC", base64Encode(new byte[] { 0x00, 0x01, 0x02 }));
307 assertEquals("//79", base64Encode(new byte[] { (byte)0xFF, (byte)0xFE, (byte)0xFD }));
308 }
309
310
311
312
313 @Test
314 void a010_base64EncodeToString() {
315 assertNull(base64EncodeToString(null));
316 assertEquals("", base64EncodeToString(""));
317 assertEquals("SGVsbG8=", base64EncodeToString("Hello"));
318 assertEquals("SGVsbG8gV29ybGQ=", base64EncodeToString("Hello World"));
319 assertEquals("QQ==", base64EncodeToString("A"));
320 assertEquals("QUI=", base64EncodeToString("AB"));
321 assertEquals("QUJD", base64EncodeToString("ABC"));
322 assertEquals("dGVzdApsaW5l", base64EncodeToString("test\nline"));
323
324
325 var original = "Hello World!";
326 var encoded = base64EncodeToString(original);
327 var decoded = base64DecodeToString(encoded);
328 assertEquals(original, decoded);
329 }
330
331
332
333
334 @Test
335 void a011_buildString() {
336 var result = buildString(sb -> {
337 sb.append("Hello");
338 sb.append(" ");
339 sb.append("World");
340 });
341 assertEquals("Hello World", result);
342
343 var joined = buildString(sb -> {
344 appendWithSeparator(sb, "a", ", ");
345 appendWithSeparator(sb, "b", ", ");
346 appendWithSeparator(sb, "c", ", ");
347 });
348 assertEquals("a, b, c", joined);
349
350 var empty = buildString(sb -> {
351
352 });
353 assertEquals("", empty);
354
355 var complex = buildString(sb -> {
356 appendIfNotEmpty(sb, "prefix");
357 appendWithSeparator(sb, "middle", "-");
358 appendWithSeparator(sb, "suffix", "-");
359 });
360 assertEquals("prefix-middle-suffix", complex);
361
362 assertThrows(IllegalArgumentException.class, () -> buildString(null));
363 }
364
365
366
367
368 @Test
369 void a012_camelCase() {
370 assertNull(camelCase(null));
371 assertEquals("", camelCase(""));
372 assertEquals("helloWorld", camelCase("hello world"));
373 assertEquals("helloWorld", camelCase("hello_world"));
374 assertEquals("helloWorld", camelCase("hello-world"));
375 assertEquals("helloWorld", camelCase("HelloWorld"));
376 assertEquals("helloWorld", camelCase("helloWorld"));
377 assertEquals("helloWorld", camelCase(" hello world "));
378 assertEquals("helloWorldTest", camelCase("Hello_World-Test"));
379 assertEquals("test", camelCase("test"));
380 assertEquals("hello123World", camelCase("hello 123 world"));
381
382
383
384
385 assertEquals("", camelCase(" "));
386 assertEquals("", camelCase("\t\t"));
387 assertEquals("", camelCase("___"));
388 assertEquals("", camelCase("---"));
389
390
391 assertEquals("!!!", camelCase("!!!"));
392 assertEquals("@#$", camelCase("@#$"));
393 assertEquals(".,;:", camelCase(".,;:"));
394
395
396
397
398
399
400
401
402
403
404
405 var result1 = camelCase("ABCDe");
406 assertEquals("aBCDe", result1);
407
408
409
410
411
412
413
414 assertEquals("xMLHt", camelCase("XMLHt"));
415
416
417
418 assertEquals("xMLHttp", camelCase("XMLHttp"));
419
420 assertEquals("!!!", camelCase(" !!! "));
421 }
422
423
424
425
426 @Test
427 void a013_capitalize() {
428 assertNull(capitalize(null));
429 assertEquals("", capitalize(""));
430 assertEquals("Hello", capitalize("hello"));
431 assertEquals("Hello", capitalize("Hello"));
432 assertEquals("HELLO", capitalize("HELLO"));
433 assertEquals("A", capitalize("a"));
434 assertEquals("123", capitalize("123"));
435 }
436
437
438
439
440 @Test
441 void a014_cdlToList() {
442 assertEquals(l("a", "b", "c"), cdlToList("a,b,c"));
443 assertEquals(l("a", "b", "c"), cdlToList(" a , b , c "));
444 assertEquals(l(), cdlToList(null));
445 assertEquals(l(), cdlToList(""));
446 assertEquals(l("a"), cdlToList("a"));
447 }
448
449
450
451
452 @Test
453 void a015_cdlToSet() {
454 assertEquals(new LinkedHashSet<>(l("a", "b", "c")), cdlToSet("a,b,c"));
455 assertEquals(new LinkedHashSet<>(l("a", "b", "c")), cdlToSet(" a , b , c "));
456 assertEquals(set(), cdlToSet(null));
457 assertEquals(set(), cdlToSet(""));
458 assertEquals(new LinkedHashSet<>(l("a")), cdlToSet("a"));
459 }
460
461
462
463
464 @Test
465 void a016_charAt() {
466 assertEquals(0, charAt(null, 0));
467 assertEquals(0, charAt("", 0));
468 assertEquals(0, charAt("test", -1));
469 assertEquals(0, charAt("test", 10));
470 assertEquals('t', charAt("test", 0));
471 assertEquals('e', charAt("test", 1));
472 assertEquals('s', charAt("test", 2));
473 assertEquals('t', charAt("test", 3));
474 }
475
476
477
478
479 @Test
480 void a017_clean() {
481 assertNull(clean(null));
482 assertEquals("", clean(""));
483 assertEquals("hello world", clean("hello\u0000\u0001world"));
484 assertEquals("hello world", clean("hello \t\n world"));
485 assertEquals("test", clean("test"));
486 }
487
488
489
490
491 @Test
492 void a018_compare() {
493
494 assertTrue(compare("a", "b") < 0);
495 assertTrue(compare("b", "a") > 0);
496 assertEquals(0, compare("a", "a"));
497
498
499 assertEquals(Integer.MIN_VALUE, compare(null, "b"));
500 assertTrue(compare(null, "b") < 0);
501
502
503 assertEquals(Integer.MAX_VALUE, compare("b", null));
504 assertTrue(compare("b", null) > 0);
505
506
507 assertEquals(0, compare(null, null));
508 }
509
510
511
512
513 @Test
514 void a019_compareIgnoreCase() {
515 assertTrue(compareIgnoreCase("apple", "BANANA") < 0);
516 assertTrue(compareIgnoreCase("BANANA", "apple") > 0);
517 assertEquals(0, compareIgnoreCase("Hello", "hello"));
518 assertEquals(0, compareIgnoreCase("HELLO", "hello"));
519 assertTrue(compareIgnoreCase("Zebra", "apple") > 0);
520 assertTrue(compareIgnoreCase("apple", "Zebra") < 0);
521 assertEquals(0, compareIgnoreCase(null, null));
522 assertTrue(compareIgnoreCase(null, "test") < 0);
523 assertTrue(compareIgnoreCase("test", null) > 0);
524 }
525
526
527
528
529 @Test
530 void a020_compress() throws Exception {
531
532 var original = "Hello World! This is a test string that should compress well.";
533 var compressed = compress(original);
534 assertNotNull(compressed);
535 assertTrue(compressed.length > 0);
536
537
538 var emptyCompressed = compress("");
539 assertNotNull(emptyCompressed);
540 }
541
542
543
544
545
546
547
548
549
550
551
552
553 @Test
554 void a021_contains() {
555
556 assertTrue(contains("test", 't'));
557 assertTrue(contains("test", 'e'));
558 assertFalse(contains("test", 'x'));
559 assertFalse(contains(null, 't'));
560
561
562 assertTrue(contains("test", "te"));
563 assertTrue(contains("test", "st"));
564 assertFalse(contains("test", "xx"));
565 assertFalse(contains(null, "test"));
566
567
568 assertTrue(contains("test", "test"));
569 assertTrue(contains("hello world", "world"));
570 assertFalse(contains("test", "xyz"));
571
572
573 assertTrue(containsAny("test", 't', 'x'));
574 assertTrue(containsAny("test", 'e', 's'));
575 assertFalse(containsAny("test", 'x', 'y'));
576 assertFalse(containsAny(null, 't'));
577 assertFalse(containsAny("test", (char[])null));
578
579 assertFalse(containsAny("test", new char[0]));
580 assertFalse(containsAny(null, new char[0]));
581
582
583 assertTrue(containsAny("test", "te", "xx"));
584 assertTrue(containsAny("test", "es", "st"));
585 assertFalse(containsAny("test", "xx", "yy"));
586 assertFalse(containsAny(null, "test"));
587 assertFalse(containsAny("test", (CharSequence[])null));
588
589 assertFalse(containsAny("test", new CharSequence[0]));
590 assertFalse(containsAny(null, new CharSequence[0]));
591
592
593 assertTrue(containsAny("test", "te", "xx"));
594 assertTrue(containsAny("hello world", "world", "xyz"));
595 assertFalse(containsAny("test", "xx", "yy"));
596 assertFalse(containsAny(null, "test"));
597 assertFalse(containsAny("test", (String[])null));
598
599 assertFalse(containsAny("test", new String[0]));
600 assertFalse(containsAny(null, new String[0]));
601
602
603 assertTrue(containsAll("test", 't', 'e'));
604 assertTrue(containsAll("test", 't', 'e', 's'));
605 assertFalse(containsAll("test", 't', 'x'));
606 assertFalse(containsAll(null, 't'));
607 assertFalse(containsAll("test", (char[])null));
608
609 assertFalse(containsAll("test", new char[0]));
610 assertFalse(containsAll(null, new char[0]));
611
612
613 assertTrue(containsAll("test", "te", "st"));
614 assertFalse(containsAll("test", "te", "xx"));
615 assertFalse(containsAll(null, "test"));
616 assertFalse(containsAll("test", (CharSequence[])null));
617
618 assertFalse(containsAll("test", new CharSequence[0]));
619 assertFalse(containsAll(null, new CharSequence[0]));
620
621
622 assertTrue(containsAll("hello world", "hello", "world"));
623 assertFalse(containsAll("test", "te", "xx"));
624 assertFalse(containsAll(null, "test"));
625 assertFalse(containsAll("test", (String[])null));
626
627 assertFalse(containsAll("test", new String[0]));
628 assertFalse(containsAll(null, new String[0]));
629 }
630
631
632
633
634 @Test
635 void a022_containsCharSequence() {
636
637 assertTrue(contains("test", (CharSequence)"te"));
638 assertTrue(contains("test", (CharSequence)"st"));
639 assertFalse(contains("test", (CharSequence)"xx"));
640 assertFalse(contains(null, (CharSequence)"test"));
641
642
643 assertTrue(contains("test", new StringBuilder("te")));
644 assertTrue(contains("test", new StringBuilder("st")));
645 assertFalse(contains("test", new StringBuilder("xx")));
646 assertFalse(contains(null, new StringBuilder("test")));
647
648
649 assertTrue(contains("test", new StringBuffer("te")));
650 assertFalse(contains("test", new StringBuffer("xx")));
651 }
652
653
654
655
656 @Test
657 void a023_containsIgnoreCase() {
658 assertTrue(containsIgnoreCase("Hello World", "world"));
659 assertTrue(containsIgnoreCase("Hello World", "WORLD"));
660 assertTrue(containsIgnoreCase("Hello World", "hello"));
661 assertTrue(containsIgnoreCase("Hello World", "HELLO"));
662 assertTrue(containsIgnoreCase("Hello World", "lo wo"));
663 assertFalse(containsIgnoreCase("Hello World", "xyz"));
664 assertFalse(containsIgnoreCase(null, "test"));
665 assertFalse(containsIgnoreCase("test", null));
666 assertFalse(containsIgnoreCase(null, null));
667 assertTrue(containsIgnoreCase("Hello", "hello"));
668 }
669
670
671
672
673 @Test
674 void a024_countChars() {
675 assertEquals(0, countChars(null, 'a'));
676 assertEquals(0, countChars("", 'a'));
677 assertEquals(2, countChars("hello", 'l'));
678 assertEquals(1, countChars("hello", 'h'));
679 assertEquals(0, countChars("hello", 'x'));
680 assertEquals(3, countChars("aaa", 'a'));
681 assertEquals(0, countChars("test", ' '));
682 assertEquals(1, countChars("hello world", ' '));
683 }
684
685
686
687
688 @Test
689 void a025_countMatches() {
690 assertEquals(2, countMatches("hello world world", "world"));
691 assertEquals(3, countMatches("ababab", "ab"));
692 assertEquals(4, countMatches("aaaa", "a"));
693 assertEquals(2, countMatches("hello hello", "hello"));
694 assertEquals(0, countMatches("hello", "xyz"));
695 assertEquals(0, countMatches(null, "test"));
696 assertEquals(0, countMatches("test", null));
697 assertEquals(0, countMatches(null, null));
698 assertEquals(0, countMatches("", "test"));
699 assertEquals(0, countMatches("test", ""));
700 assertEquals(1, countMatches("hello", "hello"));
701 assertEquals(0, countMatches("hello", "hello world"));
702
703 assertEquals(2, countMatches("aaaa", "aa"));
704 }
705
706
707
708
709 @Test
710 void a026_decodeHex() {
711 assertNull(decodeHex(null));
712 assertEquals("19azAZ", decodeHex("19azAZ"));
713 assertEquals("[0][1][ffff]", decodeHex("\u0000\u0001\uFFFF"));
714 }
715
716
717
718
719 @Test
720 void a027_decompress() throws Exception {
721
722 var original = "Hello World! This is a test string that should compress well.";
723 var compressed = compress(original);
724 var decompressed = decompress(compressed);
725 assertEquals(original, decompressed);
726
727
728 var emptyCompressed = compress("");
729 var emptyDecompressed = decompress(emptyCompressed);
730 assertEquals("", emptyDecompressed);
731 }
732
733
734
735
736 @Test
737 void a028_defaultIfBlank() {
738 assertEquals("default", defaultIfBlank(null, "default"));
739 assertEquals("default", defaultIfBlank("", "default"));
740 assertEquals("default", defaultIfBlank(" ", "default"));
741 assertEquals("default", defaultIfBlank("\t", "default"));
742 assertEquals("default", defaultIfBlank("\n", "default"));
743 assertEquals("x", defaultIfBlank("x", "default"));
744 assertEquals("hello", defaultIfBlank("hello", "default"));
745 assertEquals(" x ", defaultIfBlank(" x ", "default"));
746 assertEquals("x", defaultIfBlank("x", ""));
747 assertEquals("x", defaultIfBlank("x", null));
748 assertNull(defaultIfBlank(null, null));
749 assertNull(defaultIfBlank("", null));
750 assertNull(defaultIfBlank(" ", null));
751 assertEquals("x", defaultIfBlank("x", null));
752
753 var result = defaultIfBlank("\u00A0", "default");
754 assertTrue(result.equals("default") || result.equals("\u00A0"));
755 }
756
757
758
759
760 @Test
761 void a029_defaultIfEmpty() {
762 assertEquals("default", defaultIfEmpty(null, "default"));
763 assertEquals("default", defaultIfEmpty("", "default"));
764 assertEquals("x", defaultIfEmpty("x", "default"));
765 assertEquals("hello", defaultIfEmpty("hello", "default"));
766 assertEquals(" ", defaultIfEmpty(" ", "default"));
767 assertEquals("x", defaultIfEmpty("x", ""));
768 assertEquals("x", defaultIfEmpty("x", null));
769 assertNull(defaultIfEmpty(null, null));
770 assertNull(defaultIfEmpty("", null));
771 assertEquals("x", defaultIfEmpty("x", null));
772 }
773
774
775
776
777 @Test
778 void a030_diffPosition() {
779 assertEquals(-1, diffPosition("a", "a"));
780 assertEquals(-1, diffPosition(null, null));
781 assertEquals(-1, diffPosition("identical", "identical"));
782 assertEquals(0, diffPosition("a", "b"));
783 assertEquals(1, diffPosition("aa", "ab"));
784 assertEquals(1, diffPosition("aaa", "ab"));
785 assertEquals(1, diffPosition("aa", "abb"));
786 assertEquals(0, diffPosition("a", null));
787 assertEquals(0, diffPosition(null, "b"));
788 assertEquals(3, diffPosition("abc", "abcdef"));
789 assertEquals(2, diffPosition("abcd", "ab"));
790
791 assertEquals(-1, diffPosition("hello", "hello"));
792 assertEquals(-1, diffPosition("test", "test"));
793 assertEquals(-1, diffPosition("", ""));
794 }
795
796
797
798
799 @Test
800 void a031_diffPositionIc() {
801 assertEquals(-1, diffPositionIc("a", "a"));
802 assertEquals(-1, diffPositionIc("a", "A"));
803 assertEquals(-1, diffPositionIc(null, null));
804 assertEquals(0, diffPositionIc("a", "b"));
805
806 assertEquals(-1, diffPositionIc("hello", "HELLO"));
807 assertEquals(-1, diffPositionIc("test", "TEST"));
808 assertEquals(-1, diffPositionIc("", ""));
809 assertEquals(1, diffPositionIc("aa", "ab"));
810 assertEquals(1, diffPositionIc("Aa", "ab"));
811 assertEquals(1, diffPositionIc("aa", "Ab"));
812 assertEquals(0, diffPositionIc("a", null));
813 assertEquals(0, diffPositionIc(null, "b"));
814 }
815
816
817
818
819 @Test
820 void a032_distinct() {
821 assertNull(distinct(null));
822 assertList(distinct(a()));
823 assertList(distinct(a("foo", "bar", "baz")), "foo", "bar", "baz");
824 assertList(distinct(a("foo", "bar", "foo", "baz", "bar")), "foo", "bar", "baz");
825 assertList(distinct(a("a", "a", "a", "a")), "a");
826 assertList(distinct(a("x", "y", "x", "z", "y", "x")), "x", "y", "z");
827 assertList(distinct(a("test")), "test");
828 assertList(distinct(a("", "", "foo", "", "bar")), "", "foo", "bar");
829 }
830
831
832
833
834 @Test
835 void a033_doubleMetaphone() {
836
837 var codes1 = doubleMetaphone("Smith");
838 assertNotNull(codes1);
839 assertEquals(2, codes1.length);
840 assertNotNull(codes1[0]);
841 assertNotNull(codes1[1]);
842
843 var codes2 = doubleMetaphone("Schmidt");
844 assertNotNull(codes2);
845 assertEquals(2, codes2.length);
846
847
848 assertNull(doubleMetaphone(null));
849 assertNull(doubleMetaphone(""));
850
851
852
853 var codes3 = doubleMetaphone("123");
854
855
856 if (codes3 != null) {
857 assertEquals(2, codes3.length);
858 }
859 }
860
861
862
863
864 @Test
865 void a034_emptyIfNull() {
866 assertEquals("", emptyIfNull(null));
867 assertEquals("", emptyIfNull(""));
868 assertEquals("x", emptyIfNull("x"));
869 assertEquals("hello", emptyIfNull("hello"));
870 assertEquals(" ", emptyIfNull(" "));
871 }
872
873
874
875
876
877 @Test
878 void a035_endsWith() {
879
880 assertFalse(endsWith(null, 'a'));
881 assertFalse(endsWith("", 'a'));
882 assertTrue(endsWith("a", 'a'));
883 assertTrue(endsWith("ba", 'a'));
884 assertFalse(endsWith("ab", 'a'));
885
886
887 assertTrue(endsWith("Hello World", "World"));
888 assertFalse(endsWith("Hello World", "Hello"));
889 assertFalse(endsWith(null, "World"));
890 assertTrue(endsWith("test", "test"));
891 assertTrue(endsWith("test", ""));
892 }
893
894
895
896
897
898 @Test
899 void a036_endsWithAny() {
900
901 assertTrue(endsWithAny("Hello", 'o', 'x'));
902 assertTrue(endsWithAny("test", 't', 's'));
903 assertFalse(endsWithAny("Hello", 'x', 'y'));
904 assertFalse(endsWithAny(null, 'o'));
905 assertFalse(endsWithAny("", 'o'));
906
907
908 assertTrue(endsWithAny("Hello World", "World", "Foo"));
909 assertTrue(endsWithAny("test.txt", ".txt", ".log"));
910 assertFalse(endsWithAny("Hello World", "Hello", "Foo"));
911 assertFalse(endsWithAny(null, "World"));
912 assertFalse(endsWithAny("test", (String[])null));
913
914 assertFalse(endsWithAny("test", new String[0]));
915 assertFalse(endsWithAny(null, new String[0]));
916 }
917
918
919
920
921 @Test
922 void a037_endsWithIgnoreCase() {
923 assertTrue(endsWithIgnoreCase("Hello World", "world"));
924 assertTrue(endsWithIgnoreCase("Hello World", "WORLD"));
925 assertTrue(endsWithIgnoreCase("Hello World", "World"));
926 assertTrue(endsWithIgnoreCase("hello world", "WORLD"));
927 assertFalse(endsWithIgnoreCase("Hello World", "hello"));
928 assertFalse(endsWithIgnoreCase("Hello World", "xyz"));
929 assertFalse(endsWithIgnoreCase(null, "test"));
930 assertFalse(endsWithIgnoreCase("test", null));
931 assertFalse(endsWithIgnoreCase(null, null));
932 assertTrue(endsWithIgnoreCase("Hello", "hello"));
933 }
934
935
936
937
938 @Test
939 void a038_entropy() {
940
941 assertEquals(0.0, entropy("aaaa"), 0.0001);
942
943
944 var entropy1 = entropy("abcd");
945 assertTrue(entropy1 > 1.5);
946
947
948 var entropy2 = entropy("hello");
949 assertTrue(entropy2 > 0.0 && entropy2 < 3.0);
950
951
952 var entropy3 = entropy("aabbcc");
953 assertTrue(entropy3 > 0.0);
954
955
956 assertEquals(0.0, entropy("a"), 0.0001);
957
958
959 assertEquals(0.0, entropy(null), 0.0001);
960 assertEquals(0.0, entropy(""), 0.0001);
961 }
962
963
964
965
966 @Test
967 void a039_equalsIgnoreCase() {
968 assertTrue(equalsIgnoreCase("Hello", "hello"));
969 assertTrue(equalsIgnoreCase("HELLO", "hello"));
970 assertTrue(equalsIgnoreCase("Hello", "HELLO"));
971 assertTrue(equalsIgnoreCase("Hello", "Hello"));
972 assertFalse(equalsIgnoreCase("Hello", "World"));
973 assertTrue(equalsIgnoreCase(null, null));
974 assertFalse(equalsIgnoreCase(null, "test"));
975 assertFalse(equalsIgnoreCase("test", null));
976 assertTrue(equalsIgnoreCase("", ""));
977 }
978
979
980
981
982 @Test
983 void a040_equalsIgnoreCaseObject() {
984
985 assertTrue(equalsIgnoreCase((Object)null, (Object)null));
986
987
988 assertFalse(equalsIgnoreCase((Object)null, "test"));
989 assertFalse(equalsIgnoreCase("test", (Object)null));
990
991
992 assertTrue(equalsIgnoreCase((Object)"Hello", (Object)"hello"));
993 assertTrue(equalsIgnoreCase((Object)"HELLO", (Object)"hello"));
994 assertFalse(equalsIgnoreCase((Object)"Hello", (Object)"World"));
995
996
997 assertTrue(equalsIgnoreCase(123, "123"));
998 assertTrue(equalsIgnoreCase("123", 123));
999 assertFalse(equalsIgnoreCase(123, "456"));
1000
1001
1002 var obj1 = new Object() {
1003 @Override
1004 public String toString() { return "TEST"; }
1005 };
1006 var obj2 = new Object() {
1007 @Override
1008 public String toString() { return "test"; }
1009 };
1010 assertTrue(equalsIgnoreCase(obj1, obj2));
1011 assertTrue(equalsIgnoreCase(obj1, "TEST"));
1012 }
1013
1014
1015
1016
1017 @Test
1018 void a041_escapeChars() {
1019 var escape = AsciiSet.of("\\,|");
1020
1021 assertNull(escapeChars(null, escape));
1022 assertEquals("", escapeChars("", escape));
1023 assertEquals("xxx", escapeChars("xxx", escape));
1024 assertEquals("x\\,xx", escapeChars("x,xx", escape));
1025 assertEquals("x\\|xx", escapeChars("x|xx", escape));
1026 assertEquals("x\\\\xx", escapeChars("x\\xx", escape));
1027 assertEquals("x\\,\\|xx", escapeChars("x,|xx", escape));
1028
1029
1030 var escape2 = AsciiSet.of(",|");
1031 assertEquals("x\\xx", escapeChars("x\\xx", escape2));
1032 }
1033
1034
1035
1036
1037 @Test
1038 void a042_escapeForJava() {
1039 assertNull(escapeForJava(null));
1040 assertEquals("", escapeForJava(""));
1041 assertEquals("Hello World", escapeForJava("Hello World"));
1042 assertEquals("Hello\\nWorld", escapeForJava("Hello\nWorld"));
1043 assertEquals("Hello\\r\\nWorld", escapeForJava("Hello\r\nWorld"));
1044 assertEquals("Hello\\tWorld", escapeForJava("Hello\tWorld"));
1045 assertEquals("Hello\\\"World\\\"", escapeForJava("Hello\"World\""));
1046 assertEquals("Hello\\\\World", escapeForJava("Hello\\World"));
1047 assertEquals("Hello\\u0000World", escapeForJava("Hello\u0000World"));
1048 assertEquals("Test\\u0001Test", escapeForJava("Test\u0001Test"));
1049
1050
1051 assertEquals("Test\\fTest", escapeForJava("Test\fTest"));
1052
1053
1054 assertEquals("Test\\bTest", escapeForJava("Test\bTest"));
1055
1056
1057 assertEquals("Test\\u0080Test", escapeForJava("Test\u0080Test"));
1058 assertEquals("Test\\u001fTest", escapeForJava("Test\u001FTest"));
1059 assertEquals("Test\\u00a0Test", escapeForJava("Test\u00A0Test"));
1060 assertEquals("Test\\u0100Test", escapeForJava("Test\u0100Test"));
1061 }
1062
1063
1064
1065
1066 @Test
1067 void a043_escapeHtml() {
1068 assertNull(escapeHtml(null));
1069 assertEquals("", escapeHtml(""));
1070 assertEquals("Hello World", escapeHtml("Hello World"));
1071 assertEquals("<script>", escapeHtml("<script>"));
1072 assertEquals(""Hello"", escapeHtml("\"Hello\""));
1073 assertEquals("It's a test", escapeHtml("It's a test"));
1074 assertEquals("&", escapeHtml("&"));
1075 assertEquals("<tag>text</tag>", escapeHtml("<tag>text</tag>"));
1076
1077 assertEquals("&", escapeHtml("&"));
1078 assertEquals("<", escapeHtml("<"));
1079 assertEquals(">", escapeHtml(">"));
1080 assertEquals(""", escapeHtml("\""));
1081 assertEquals("'", escapeHtml("'"));
1082 }
1083
1084
1085
1086
1087 @Test
1088 void a044_escapeRegex() {
1089 assertNull(escapeRegex(null));
1090 assertEquals("", escapeRegex(""));
1091 assertEquals("Hello World", escapeRegex("Hello World"));
1092 assertEquals("file\\.txt", escapeRegex("file.txt"));
1093 assertEquals("price: \\$10\\.99", escapeRegex("price: $10.99"));
1094 assertEquals("test\\*\\+\\?", escapeRegex("test*+?"));
1095 assertEquals("\\^\\.\\*\\+\\?\\$", escapeRegex("^.*+?$"));
1096 assertEquals("\\{\\}\\(\\)\\[\\]\\|\\\\", escapeRegex("{}()[]|\\"));
1097
1098 assertTrue(escapeRegex("file.txt").contains("\\."));
1099 }
1100
1101
1102
1103
1104 @Test
1105 void a045_escapeSql() {
1106 assertNull(escapeSql(null));
1107 assertEquals("", escapeSql(""));
1108 assertEquals("Hello World", escapeSql("Hello World"));
1109 assertEquals("O''Brien", escapeSql("O'Brien"));
1110 assertEquals("It''s a test", escapeSql("It's a test"));
1111 assertEquals("''", escapeSql("'"));
1112 assertEquals("''''", escapeSql("''"));
1113 assertEquals("John''s book", escapeSql("John's book"));
1114 }
1115
1116
1117
1118
1119 @Test
1120 void a046_escapeXml() {
1121 assertNull(escapeXml(null));
1122 assertEquals("", escapeXml(""));
1123 assertEquals("Hello World", escapeXml("Hello World"));
1124 assertEquals("<tag>", escapeXml("<tag>"));
1125 assertEquals(""Hello"", escapeXml("\"Hello\""));
1126 assertEquals("It's a test", escapeXml("It's a test"));
1127 assertEquals("&", escapeXml("&"));
1128 assertEquals("<tag attr='value'>text</tag>", escapeXml("<tag attr='value'>text</tag>"));
1129
1130 assertEquals("&", escapeXml("&"));
1131 assertEquals("<", escapeXml("<"));
1132 assertEquals(">", escapeXml(">"));
1133 assertEquals(""", escapeXml("\""));
1134 assertEquals("'", escapeXml("'"));
1135 }
1136
1137
1138
1139
1140 @Test
1141 void a047_extractBetween() {
1142
1143 var results1 = extractBetween("<tag>content</tag>", "<", ">");
1144 assertEquals(2, results1.size());
1145 assertEquals("tag", results1.get(0));
1146 assertEquals("/tag", results1.get(1));
1147
1148
1149 var results2 = extractBetween("[one][two][three]", "[", "]");
1150 assertEquals(3, results2.size());
1151 assertEquals("one", results2.get(0));
1152 assertEquals("two", results2.get(1));
1153 assertEquals("three", results2.get(2));
1154
1155
1156 var results3 = extractBetween("(outer (inner) outer)", "(", ")");
1157 assertEquals(1, results3.size());
1158 assertTrue(results3.get(0).contains("outer"));
1159
1160
1161 assertTrue(extractBetween("no markers here", "<", ">").isEmpty());
1162
1163
1164 assertTrue(extractBetween(null, "<", ">").isEmpty());
1165 assertTrue(extractBetween("", "<", ">").isEmpty());
1166
1167
1168 assertTrue(extractBetween("test", "", ">").isEmpty());
1169 assertTrue(extractBetween("test", "<", "").isEmpty());
1170 assertTrue(extractBetween("test", "", "").isEmpty());
1171
1172
1173 var results4 = extractBetween("start<content>end", "<", "X");
1174 assertTrue(results4.isEmpty());
1175
1176 var results5 = extractBetween("start<content1>middle<content2>end", "<", "X");
1177 assertTrue(results5.isEmpty());
1178
1179
1180 var results6 = extractBetween("text<unclosed", "<", ">");
1181 assertTrue(results6.isEmpty());
1182
1183
1184 var results7 = extractBetween("before<start1>middle<start2>end<start3", "<", ">");
1185
1186
1187
1188 assertEquals(2, results7.size());
1189 assertEquals("start1", results7.get(0));
1190 assertEquals("start2", results7.get(1));
1191 }
1192
1193
1194
1195
1196 @Test
1197 void a048_extractEmails() {
1198
1199 var emails1 = extractEmails("Contact: user@example.com or admin@test.org");
1200 assertEquals(2, emails1.size());
1201 assertTrue(emails1.contains("user@example.com"));
1202 assertTrue(emails1.contains("admin@test.org"));
1203
1204
1205 var emails2 = extractEmails("Email me at john.doe@example.com, or contact jane@test.org");
1206 assertEquals(2, emails2.size());
1207 assertTrue(emails2.contains("john.doe@example.com"));
1208 assertTrue(emails2.contains("jane@test.org"));
1209
1210
1211 var emails3 = extractEmails("user+tag@example.co.uk is valid");
1212 assertEquals(1, emails3.size());
1213 assertEquals("user+tag@example.co.uk", emails3.get(0));
1214
1215
1216 assertTrue(extractEmails("No email addresses here").isEmpty());
1217
1218
1219 assertTrue(extractEmails(null).isEmpty());
1220 assertTrue(extractEmails("").isEmpty());
1221 }
1222
1223
1224
1225
1226 @Test
1227 void a049_extractNumbers() {
1228
1229 var numbers1 = extractNumbers("Price: $19.99, Quantity: 5");
1230 assertEquals(2, numbers1.size());
1231 assertEquals("19.99", numbers1.get(0));
1232 assertEquals("5", numbers1.get(1));
1233
1234
1235 var numbers2 = extractNumbers("Version 1.2.3 has 42 features");
1236 assertEquals(3, numbers2.size());
1237 assertEquals("1.2", numbers2.get(0));
1238 assertEquals("3", numbers2.get(1));
1239 assertEquals("42", numbers2.get(2));
1240
1241
1242 var numbers3 = extractNumbers("3.14 and 2.718 are constants");
1243 assertEquals(2, numbers3.size());
1244 assertEquals("3.14", numbers3.get(0));
1245 assertEquals("2.718", numbers3.get(1));
1246
1247
1248 var numbers4 = extractNumbers("1 2 3 4 5");
1249 assertEquals(5, numbers4.size());
1250 assertEquals("1", numbers4.get(0));
1251 assertEquals("5", numbers4.get(4));
1252
1253
1254 assertTrue(extractNumbers("No numbers here").isEmpty());
1255
1256
1257 assertTrue(extractNumbers(null).isEmpty());
1258 assertTrue(extractNumbers("").isEmpty());
1259 }
1260
1261
1262
1263
1264 @Test
1265 void a050_extractUrls() {
1266
1267 var urls1 = extractUrls("Visit https://example.com or http://test.org");
1268 assertEquals(2, urls1.size());
1269 assertTrue(urls1.contains("https://example.com"));
1270 assertTrue(urls1.contains("http://test.org"));
1271
1272
1273 var urls2 = extractUrls("Check https://example.com/path/to/page?param=value");
1274 assertEquals(1, urls2.size());
1275 assertTrue(urls2.get(0).startsWith("https://example.com"));
1276
1277
1278 var urls3 = extractUrls("Download from ftp://files.example.com/pub/data");
1279 assertEquals(1, urls3.size());
1280 assertTrue(urls3.get(0).startsWith("ftp://"));
1281
1282
1283 var urls4 = extractUrls("Links: http://site1.com and https://site2.org/page");
1284 assertEquals(2, urls4.size());
1285
1286
1287 assertTrue(extractUrls("No URLs here").isEmpty());
1288
1289
1290 assertTrue(extractUrls(null).isEmpty());
1291 assertTrue(extractUrls("").isEmpty());
1292 }
1293
1294
1295
1296
1297 @Test
1298 void a051_extractWords() {
1299
1300 var words1 = extractWords("Hello world! This is a test.");
1301 assertEquals(6, words1.size());
1302 assertEquals("Hello", words1.get(0));
1303 assertEquals("world", words1.get(1));
1304 assertEquals("This", words1.get(2));
1305 assertEquals("is", words1.get(3));
1306 assertEquals("a", words1.get(4));
1307 assertEquals("test", words1.get(5));
1308
1309
1310 var words2 = extractWords("variable_name and test_123");
1311 assertEquals(3, words2.size());
1312 assertTrue(words2.contains("variable_name"));
1313 assertTrue(words2.contains("and"));
1314 assertTrue(words2.contains("test_123"));
1315
1316
1317 var words3 = extractWords("Version 1.2.3 has 42 features");
1318 assertEquals(7, words3.size());
1319 assertTrue(words3.contains("Version"));
1320 assertTrue(words3.contains("1"));
1321 assertTrue(words3.contains("2"));
1322 assertTrue(words3.contains("3"));
1323 assertTrue(words3.contains("has"));
1324 assertTrue(words3.contains("42"));
1325 assertTrue(words3.contains("features"));
1326
1327
1328 assertTrue(extractWords("!@#$%^&*()").isEmpty());
1329
1330
1331 assertTrue(extractWords(null).isEmpty());
1332 assertTrue(extractWords("").isEmpty());
1333 }
1334
1335
1336
1337
1338 @Test
1339 void a052_filter() {
1340 assertNull(filter(null, NOT_EMPTY));
1341 assertList(filter(a(), NOT_EMPTY));
1342 assertList(filter(a("foo", "", "bar", null, "baz"), NOT_EMPTY), "foo", "bar", "baz");
1343 assertList(filter(a("foo", "", "bar", null, "baz"), null));
1344 assertList(filter(a("hello", "world", "test"), s -> s.length() > 4), "hello", "world");
1345 assertList(filter(a("a", "bb", "ccc", "dddd"), s -> s.length() == 2), "bb");
1346 assertList(filter(a("foo", "bar", "baz"), s -> s.startsWith("b")), "bar", "baz");
1347 assertList(filter(a("test"), s -> false));
1348 assertList(filter(a("test"), s -> true), "test");
1349 }
1350
1351
1352
1353
1354 @Test
1355 void a053_firstChar() {
1356 assertEquals('H', firstChar("Hello"));
1357 assertEquals('W', firstChar("World"));
1358 assertEquals('a', firstChar("a"));
1359 assertEquals(0, firstChar(""));
1360 assertEquals(0, firstChar(null));
1361 }
1362
1363
1364
1365
1366 @Test
1367 void a054_firstNonBlank() {
1368 assertEquals("test", firstNonBlank("test"));
1369 assertEquals("test", firstNonBlank(null, "test"));
1370 assertEquals("test", firstNonBlank("", "test"));
1371 assertEquals("test", firstNonBlank(" ", "test"));
1372 assertEquals("test", firstNonBlank(null, "", " ", "test"));
1373 assertNull(firstNonBlank());
1374 assertNull(firstNonBlank((String)null));
1375 assertNull(firstNonBlank(null, null));
1376 assertNull(firstNonBlank("", ""));
1377 assertNull(firstNonBlank(" ", " "));
1378 }
1379
1380
1381
1382
1383 @Test
1384 void a055_firstNonEmpty() {
1385 assertEquals("test", firstNonEmpty("test"));
1386 assertEquals("test", firstNonEmpty(null, "test"));
1387 assertEquals("test", firstNonEmpty("", "test"));
1388 assertEquals("test", firstNonEmpty(null, "", "test"));
1389 assertNull(firstNonEmpty());
1390 assertNull(firstNonEmpty((String)null));
1391 assertNull(firstNonEmpty(null, null));
1392 assertNull(firstNonEmpty("", ""));
1393 assertEquals(" ", firstNonEmpty(" "));
1394 }
1395
1396
1397
1398
1399 @Test
1400 void a056_firstNonWhitespaceChar() {
1401 assertEquals('f', firstNonWhitespaceChar("foo"));
1402 assertEquals('f', firstNonWhitespaceChar(" foo"));
1403 assertEquals('f', firstNonWhitespaceChar("\tfoo"));
1404 assertEquals('f', firstNonWhitespaceChar("\n\t foo"));
1405 assertEquals(0, firstNonWhitespaceChar(""));
1406 assertEquals(0, firstNonWhitespaceChar(" "));
1407 assertEquals(0, firstNonWhitespaceChar("\t"));
1408 assertEquals(0, firstNonWhitespaceChar("\n\t "));
1409 assertEquals(0, firstNonWhitespaceChar(null));
1410 }
1411
1412
1413
1414
1415 @Test
1416 void a057_fixUrl() {
1417 assertNull(fixUrl(null));
1418 assertEquals("", fixUrl(""));
1419 assertEquals("xxx", fixUrl("xxx"));
1420 assertEquals("+x+x+", fixUrl(" x x "));
1421 assertEquals("++x++x++", fixUrl(" x x "));
1422 assertEquals("foo%7Bbar%7Dbaz", fixUrl("foo{bar}baz"));
1423 assertEquals("%7Dfoo%7Bbar%7Dbaz%7B", fixUrl("}foo{bar}baz{"));
1424 assertEquals("%E9", fixUrl("é"));
1425 }
1426
1427
1428
1429
1430 @Test
1431 void a058_format() {
1432
1433 assertEquals("Hello John, you have 5 items", format("Hello %s, you have %d items", "John", 5));
1434 assertEquals("Hello world", format("Hello %s", "world"));
1435
1436
1437 assertEquals("Price: $19.99", format("Price: $%.2f", 19.99));
1438 assertEquals("Value: 3.14", format("Value: %.2f", 3.14159));
1439 assertEquals("Value: 3.142", format("Value: %.3f", 3.14159));
1440
1441
1442 assertEquals("Name: John Age: 25", format("Name: %-20s Age: %3d", "John", 25));
1443 assertEquals("Name: John Age: 25", format("Name: %20s Age: %3d", "John", 25));
1444 assertEquals("Number: 42", format("Number: %4d", 42));
1445 assertEquals("Number: 0042", format("Number: %04d", 42));
1446
1447
1448 assertEquals("Color: #FF5733", format("Color: #%06X", 0xFF5733));
1449 assertEquals("Hex: ff5733", format("Hex: %x", 0xFF5733));
1450 assertEquals("Hex: FF5733", format("Hex: %X", 0xFF5733));
1451 assertEquals("Hex: 255", format("Hex: %d", 0xFF));
1452
1453
1454 assertEquals("Octal: 377", format("Octal: %o", 255));
1455
1456
1457 assertEquals("Value: 1.23e+06", format("Value: %.2e", 1234567.0));
1458 assertEquals("Value: 1.23E+06", format("Value: %.2E", 1234567.0));
1459
1460
1461 assertEquals("Flag: true", format("Flag: %b", true));
1462 assertEquals("Flag: false", format("Flag: %b", false));
1463 assertEquals("Flag: true", format("Flag: %b", "anything"));
1464
1465
1466 assertEquals("Char: A", format("Char: %c", 'A'));
1467 assertEquals("Char: A", format("Char: %c", 65));
1468
1469
1470 assertEquals("Alice loves Bob, and Alice also loves Charlie", format("%1$s loves %2$s, and %1$s also loves %3$s", "Alice", "Bob", "Charlie"));
1471
1472
1473 assertEquals("Progress: 50%", format("Progress: %d%%", 50));
1474 assertEquals("Discount: 25% off", format("Discount: %d%% off", 25));
1475
1476
1477
1478
1479 var lineSep = System.lineSeparator();
1480 assertEquals("Line 1" + lineSep + "Line 2", format("Line 1%nLine 2", "dummy"));
1481
1482
1483 assertEquals("Hello John, you are 30 years old", format("Hello {0}, you are {1} years old", "John", 30));
1484 assertEquals("Hello {0}", format("Hello {0}"));
1485 assertEquals("Hello {}", format("Hello {}"));
1486 }
1487
1488
1489
1490
1491 @Test
1492 void a059_formatNamed() {
1493 var args = new HashMap<String,Object>();
1494 args.put("name", "John");
1495 args.put("age", 30);
1496 args.put("city", "New York");
1497 assertEquals("Hello John, you are 30 years old", formatNamed("Hello {name}, you are {age} years old", args));
1498 assertEquals("Welcome to New York", formatNamed("Welcome to {city}", args));
1499 assertEquals("Hello {unknown}", formatNamed("Hello {unknown}", args));
1500 assertEquals("No placeholders", formatNamed("No placeholders", args));
1501 assertNull(formatNamed(null, args));
1502 assertEquals("Template", formatNamed("Template", null));
1503 assertEquals("Template", formatNamed("Template", new HashMap<>()));
1504
1505 var argsWithNull = new HashMap<String,Object>();
1506 argsWithNull.put("name", "John");
1507 argsWithNull.put("value", null);
1508 assertEquals("Hello John, value: ", formatNamed("Hello {name}, value: {value}", argsWithNull));
1509
1510
1511 var argsNested = new HashMap<String,Object>();
1512 argsNested.put("outer", "value");
1513 argsNested.put("inner", "nested");
1514
1515
1516
1517 assertEquals("{value}", formatNamed("{{outer}}", argsNested));
1518
1519
1520 argsNested.put("key", "name");
1521 argsNested.put("name", "John");
1522
1523 assertEquals("John", formatNamed("{{key}}", argsNested));
1524
1525
1526 var argsExists = new HashMap<String,Object>();
1527 argsExists.put("key1", "value1");
1528 argsExists.put("key2", null);
1529 assertEquals("value1", formatNamed("{key1}", argsExists));
1530 assertEquals("", formatNamed("{key2}", argsExists));
1531
1532
1533 var argsRecursive = new HashMap<String,Object>();
1534 argsRecursive.put("outer", "{inner}");
1535 argsRecursive.put("inner", "final");
1536 assertEquals("final", formatNamed("{outer}", argsRecursive));
1537 }
1538
1539
1540
1541
1542 @Test
1543 void a060_fromHex() {
1544
1545 var bytes1 = fromHex("48656C6C6F");
1546 assertEquals(5, bytes1.length);
1547 assertEquals((byte)'H', bytes1[0]);
1548 assertEquals((byte)'e', bytes1[1]);
1549 assertEquals((byte)'l', bytes1[2]);
1550 assertEquals((byte)'l', bytes1[3]);
1551 assertEquals((byte)'o', bytes1[4]);
1552
1553
1554 var bytes2 = fromHex("FF");
1555 assertEquals(1, bytes2.length);
1556 assertEquals((byte)0xFF, bytes2[0]);
1557
1558
1559 var bytes3 = fromHex("0102");
1560 assertEquals(2, bytes3.length);
1561 assertEquals((byte)0x01, bytes3[0]);
1562 assertEquals((byte)0x02, bytes3[1]);
1563
1564
1565 var bytes4 = fromHex("0000");
1566 assertEquals(2, bytes4.length);
1567 assertEquals((byte)0x00, bytes4[0]);
1568 assertEquals((byte)0x00, bytes4[1]);
1569
1570
1571 var bytes5 = fromHex("");
1572 assertEquals(0, bytes5.length);
1573 }
1574
1575
1576
1577
1578 @Test
1579 void a061_fromHexToUTF8() {
1580
1581 assertEquals("Hello", fromHexToUTF8("48656C6C6F"));
1582 assertEquals("World", fromHexToUTF8("576F726C64"));
1583
1584
1585 assertEquals("test", fromHexToUTF8("74657374"));
1586
1587
1588 assertEquals("", fromHexToUTF8(""));
1589 }
1590
1591
1592
1593
1594 @Test
1595 void a062_fromSpacedHex() {
1596
1597 var bytes1 = fromSpacedHex("48 65 6C 6C 6F");
1598 assertEquals(5, bytes1.length);
1599 assertEquals((byte)'H', bytes1[0]);
1600 assertEquals((byte)'e', bytes1[1]);
1601 assertEquals((byte)'l', bytes1[2]);
1602 assertEquals((byte)'l', bytes1[3]);
1603 assertEquals((byte)'o', bytes1[4]);
1604
1605
1606 var bytes2 = fromSpacedHex("FF");
1607 assertEquals(1, bytes2.length);
1608 assertEquals((byte)0xFF, bytes2[0]);
1609
1610
1611 var bytes3 = fromSpacedHex("01 02");
1612 assertEquals(2, bytes3.length);
1613 assertEquals((byte)0x01, bytes3[0]);
1614 assertEquals((byte)0x02, bytes3[1]);
1615 }
1616
1617
1618
1619
1620 @Test
1621 void a063_fromSpacedHexToUTF8() {
1622
1623 assertEquals("Hello", fromSpacedHexToUTF8("48 65 6C 6C 6F"));
1624 assertEquals("World", fromSpacedHexToUTF8("57 6F 72 6C 64"));
1625
1626
1627 assertEquals("test", fromSpacedHexToUTF8("74 65 73 74"));
1628
1629
1630 assertEquals("", fromSpacedHexToUTF8(""));
1631 }
1632
1633
1634
1635
1636 @Test
1637 void a064_generateUUID() {
1638
1639 for (var i = 0; i < 10; i++) {
1640 var uuid = generateUUID();
1641 assertNotNull(uuid);
1642
1643 assertEquals(36, uuid.length());
1644 assertTrue(uuid.matches("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"));
1645 }
1646
1647 var uuid1 = generateUUID();
1648 var uuid2 = generateUUID();
1649 assertNotEquals(uuid1, uuid2);
1650 }
1651
1652
1653
1654
1655 @Test
1656 void a065_getAuthorityUri() {
1657 assertEquals("http://foo", getAuthorityUri("http://foo"));
1658 assertEquals("http://foo:123", getAuthorityUri("http://foo:123"));
1659 assertEquals("http://foo:123", getAuthorityUri("http://foo:123/"));
1660 assertEquals("http://foo:123", getAuthorityUri("http://foo:123/bar"));
1661 assertEquals("https://example.com", getAuthorityUri("https://example.com/path/to/resource"));
1662 assertEquals("ftp://server.com:21", getAuthorityUri("ftp://server.com:21/files"));
1663
1664
1665
1666 assertEquals("123http://foo", getAuthorityUri("123http://foo")); // Starts with number
1667 assertEquals(" http://foo", getAuthorityUri(" http://foo")); // Starts with space
1668
1669
1670 assertEquals("httpx://foo", getAuthorityUri("httpx://foo")); // 'x' after 'http' (invalid)
1671 assertEquals("http1://foo", getAuthorityUri("http1://foo")); // Number after 'http'
1672
1673
1674 assertEquals("http:x://foo", getAuthorityUri("http:x://foo")); // 'x' instead of '/'
1675 assertEquals("http:://foo", getAuthorityUri("http:://foo")); // ':' instead of '/'
1676
1677
1678 assertEquals("http:/x://foo", getAuthorityUri("http:/x://foo")); // 'x' instead of second '/'
1679 assertEquals("http:/://foo", getAuthorityUri("http:/://foo")); // ':' instead of second '/'
1680
1681
1682 assertEquals("http:///foo", getAuthorityUri("http:///foo")); // Third '/' instead of hostname
1683 }
1684
1685
1686
1687
1688 @Test
1689 void a066_getDuration() {
1690
1691 assertEquals(-1, getDuration(null));
1692 assertEquals(-1, getDuration(""));
1693 assertEquals(-1, getDuration(" "));
1694 assertEquals(1, getDuration("1"));
1695 assertEquals(10, getDuration("10"));
1696
1697 long s = 1000, m = s * 60, h = m * 60, d = h * 24, w = d * 7, mo = d * 30, y = d * 365;
1698
1699
1700 assertEquals(10 * s, getDuration("10s"));
1701 assertEquals(10 * s, getDuration("10 s"));
1702 assertEquals(10 * s, getDuration(" 10 s "));
1703 assertEquals(10 * s, getDuration("10sec"));
1704 assertEquals(10 * s, getDuration("10 sec"));
1705 assertEquals(10 * s, getDuration("10seconds"));
1706 assertEquals(10 * s, getDuration("10S"));
1707
1708 assertEquals(10 * m, getDuration("10m"));
1709 assertEquals(10 * m, getDuration("10 m"));
1710 assertEquals(10 * m, getDuration("10min"));
1711 assertEquals(10 * m, getDuration("10 minutes"));
1712 assertEquals(10 * m, getDuration("10M"));
1713
1714 assertEquals(10 * h, getDuration("10h"));
1715 assertEquals(10 * h, getDuration("10 h"));
1716 assertEquals(10 * h, getDuration("10hour"));
1717 assertEquals(10 * h, getDuration("10 hours"));
1718 assertEquals(10 * h, getDuration("10H"));
1719
1720 assertEquals(10 * d, getDuration("10d"));
1721 assertEquals(10 * d, getDuration("10 d"));
1722 assertEquals(10 * d, getDuration("10day"));
1723 assertEquals(10 * d, getDuration("10 days"));
1724 assertEquals(10 * d, getDuration("10D"));
1725
1726 assertEquals(10 * w, getDuration("10w"));
1727 assertEquals(10 * w, getDuration("10 w"));
1728 assertEquals(10 * w, getDuration("10week"));
1729 assertEquals(10 * w, getDuration("10 weeks"));
1730 assertEquals(10 * w, getDuration("10W"));
1731
1732
1733
1734 assertEquals(5 * s, getDuration("5sec"));
1735 assertEquals(5 * s, getDuration("5second"));
1736 assertEquals(5 * s, getDuration("5seconds"));
1737
1738
1739
1740 assertEquals(5 * m, getDuration("5m"));
1741 assertEquals(5 * m, getDuration("5min"));
1742 assertEquals(5 * m, getDuration("5minute"));
1743 assertEquals(5 * m, getDuration("5minutes"));
1744
1745
1746 assertEquals(5 * h, getDuration("5h"));
1747 assertEquals(5 * h, getDuration("5hour"));
1748 assertEquals(5 * h, getDuration("5hours"));
1749
1750
1751 assertEquals(2 * w, getDuration("2w"));
1752 assertEquals(2 * w, getDuration("2week"));
1753 assertEquals(2 * w, getDuration("2weeks"));
1754
1755
1756 assertEquals(3 * mo, getDuration("3mo"));
1757 assertEquals(3 * mo, getDuration("3month"));
1758 assertEquals(3 * mo, getDuration("3months"));
1759
1760
1761 assertEquals(2 * y, getDuration("2y"));
1762 assertEquals(2 * y, getDuration("2year"));
1763 assertEquals(2 * y, getDuration("2years"));
1764
1765
1766 assertEquals(100, getDuration("100ms"));
1767 assertEquals(100, getDuration("100 millis"));
1768 assertEquals(100, getDuration("100 milliseconds"));
1769
1770
1771 assertEquals((long)(1.5 * h), getDuration("1.5h"));
1772 assertEquals((long)(0.5 * m), getDuration("0.5m"));
1773 assertEquals((long)(2.5 * s), getDuration("2.5s"));
1774 assertEquals((long)(1.25 * d), getDuration("1.25d"));
1775
1776
1777 assertEquals(1 * h + 30 * m, getDuration("1h30m"));
1778 assertEquals(1 * h + 30 * m, getDuration("1h 30m"));
1779 assertEquals(2 * d + 3 * h + 15 * m, getDuration("2d3h15m"));
1780 assertEquals(1 * w + 2 * d + 3 * h, getDuration("1w2d3h"));
1781 assertEquals(-1, getDuration("d10"));
1782
1783
1784 assertEquals(1 * mo, getDuration("1mo"));
1785 assertEquals(1 * mo, getDuration("1 month"));
1786 assertEquals(2 * mo, getDuration("2 months"));
1787 assertEquals(6 * mo, getDuration("6mo"));
1788
1789
1790 assertEquals(1 * y, getDuration("1y"));
1791 assertEquals(1 * y, getDuration("1yr"));
1792 assertEquals(1 * y, getDuration("1 year"));
1793 assertEquals(2 * y, getDuration("2 years"));
1794 assertEquals(10 * y, getDuration("10y"));
1795
1796
1797 assertEquals(1 * y + 6 * mo, getDuration("1y6mo"));
1798 assertEquals(2 * y + 3 * mo + 5 * d, getDuration("2y3mo5d"));
1799
1800
1801
1802 assertEquals(1 * h + 30 * m, getDuration("1h 30m"));
1803 assertEquals(1 * h + 30 * m, getDuration("1h\t30m"));
1804 assertEquals(1 * h + 30 * m, getDuration("1h\n30m"));
1805 assertEquals(1 * h + 30 * m, getDuration(" 1h 30m "));
1806
1807 assertEquals(1 * h, getDuration("1h "));
1808
1809
1810 assertEquals((long)(1.5 * h), getDuration("1.5h"));
1811 assertEquals((long)(0.25 * m), getDuration("0.25m"));
1812 assertEquals((long)(3.14159 * s), getDuration("3.14159s"));
1813
1814
1815
1816
1817 assertEquals(-1, getDuration("abc"));
1818 assertEquals(-1, getDuration("h"));
1819 assertEquals(-1, getDuration("ms"));
1820 assertEquals(-1, getDuration(" h"));
1821
1822
1823 assertEquals(-1, getDuration("1xyz"));
1824 assertEquals(-1, getDuration("1invalid"));
1825 assertEquals(-1, getDuration("1.5bad"));
1826 }
1827
1828
1829
1830
1831 @Test
1832 void a067_getGlobMatchPattern() {
1833
1834 assertNull(getGlobMatchPattern(null));
1835 assertNull(getGlobMatchPattern(null, 0));
1836
1837
1838 var pattern1 = getGlobMatchPattern("test");
1839 assertNotNull(pattern1);
1840 assertTrue(pattern1.matcher("test").matches());
1841 assertFalse(pattern1.matcher("Test").matches());
1842
1843
1844 var pattern2 = getGlobMatchPattern("test*");
1845 assertNotNull(pattern2);
1846 assertTrue(pattern2.matcher("test").matches());
1847 assertTrue(pattern2.matcher("test123").matches());
1848 assertTrue(pattern2.matcher("testing").matches());
1849 assertFalse(pattern2.matcher("Test").matches());
1850
1851
1852 var pattern3 = getGlobMatchPattern("te?t");
1853 assertNotNull(pattern3);
1854 assertTrue(pattern3.matcher("test").matches());
1855 assertTrue(pattern3.matcher("teat").matches());
1856 assertFalse(pattern3.matcher("test123").matches());
1857 assertFalse(pattern3.matcher("tet").matches());
1858
1859
1860 var pattern4 = getGlobMatchPattern("te?t*");
1861 assertNotNull(pattern4);
1862 assertTrue(pattern4.matcher("test").matches());
1863 assertTrue(pattern4.matcher("test123").matches());
1864 assertTrue(pattern4.matcher("teat456").matches());
1865 assertFalse(pattern4.matcher("tet").matches());
1866
1867
1868 var pattern5 = getGlobMatchPattern("test.*");
1869 assertNotNull(pattern5);
1870 assertTrue(pattern5.matcher("test.*").matches());
1871 assertFalse(pattern5.matcher("test123").matches());
1872
1873
1874 var pattern6 = getGlobMatchPattern("test*", java.util.regex.Pattern.CASE_INSENSITIVE);
1875 assertNotNull(pattern6);
1876 assertTrue(pattern6.matcher("test").matches());
1877 assertTrue(pattern6.matcher("Test").matches());
1878 assertTrue(pattern6.matcher("TEST123").matches());
1879
1880
1881 var pattern7 = getGlobMatchPattern("*test*");
1882 assertNotNull(pattern7);
1883 assertTrue(pattern7.matcher("test").matches());
1884 assertTrue(pattern7.matcher("pretest").matches());
1885 assertTrue(pattern7.matcher("testpost").matches());
1886 assertTrue(pattern7.matcher("pretestpost").matches());
1887 }
1888
1889
1890
1891
1892
1893 @Test
1894 void a068_getMatchPattern() {
1895
1896 assertTrue(getMatchPattern("a").matcher("a").matches());
1897 assertTrue(getMatchPattern("*a*").matcher("aaa").matches());
1898 assertTrue(getMatchPattern("*a*").matcher("baa").matches());
1899 assertTrue(getMatchPattern("*a*").matcher("aab").matches());
1900 assertFalse(getMatchPattern("*b*").matcher("aaa").matches());
1901
1902
1903 assertTrue(getMatchPattern("test*").matcher("test123").matches());
1904 assertTrue(getMatchPattern("*test").matcher("123test").matches());
1905 assertTrue(getMatchPattern("test*test").matcher("test123test").matches());
1906
1907
1908 assertTrue(getMatchPattern("test?").matcher("test1").matches());
1909 assertTrue(getMatchPattern("?est").matcher("test").matches());
1910 assertFalse(getMatchPattern("test?").matcher("test12").matches());
1911
1912
1913 var pattern = getMatchPattern("TEST*", java.util.regex.Pattern.CASE_INSENSITIVE);
1914 assertTrue(pattern.matcher("test123").matches());
1915 assertTrue(pattern.matcher("TEST123").matches());
1916
1917
1918 assertNull(getMatchPattern(null));
1919 assertNull(getMatchPattern(null, java.util.regex.Pattern.CASE_INSENSITIVE));
1920 }
1921
1922
1923
1924
1925 @Test
1926 void a069_getNumberedLines() {
1927 assertNull(getNumberedLines(null));
1928 assertEquals("1: \n", getNumberedLines(""));
1929 assertEquals("1: foo\n", getNumberedLines("foo"));
1930 assertEquals("1: foo\n2: bar\n", getNumberedLines("foo\nbar"));
1931 assertEquals("1: line1\n2: line2\n3: line3\n", getNumberedLines("line1\nline2\nline3"));
1932
1933
1934 assertEquals("1: line1\n2: line2\n", getNumberedLines("line1\r\nline2"));
1935
1936
1937 assertEquals("1: line1\n2: line2\n", getNumberedLines("line1\nline2", 0, 2));
1938 assertEquals("1: line1\n2: line2\n", getNumberedLines("line1\nline2", -5, 2));
1939
1940
1941 assertEquals("1: line1\n2: line2\n3: line3\n", getNumberedLines("line1\nline2\nline3", 1, -1));
1942 }
1943
1944
1945
1946
1947 @Test
1948 void a070_getStringSize() {
1949 assertEquals(0, getStringSize(null));
1950 assertEquals(40, getStringSize(""));
1951 assertEquals(50, getStringSize("hello"));
1952 assertEquals(48, getStringSize("test"));
1953 assertEquals(60, getStringSize("1234567890"));
1954
1955
1956 var emptySize = getStringSize("");
1957 assertTrue(emptySize >= 24);
1958
1959 var oneCharSize = getStringSize("a");
1960 assertEquals(emptySize + 2, oneCharSize);
1961
1962 var tenCharSize = getStringSize("1234567890");
1963 assertEquals(emptySize + 20, tenCharSize);
1964 }
1965
1966
1967
1968
1969 @Test
1970 void a071_hasText() {
1971 assertFalse(hasText(null));
1972 assertFalse(hasText(""));
1973 assertFalse(hasText(" "));
1974 assertFalse(hasText("\t\n"));
1975 assertTrue(hasText("hello"));
1976 assertTrue(hasText(" hello "));
1977 assertTrue(hasText("a"));
1978 assertTrue(hasText(" hello "));
1979 }
1980
1981
1982
1983
1984 @Test
1985 void a072_indexOf() {
1986 assertEquals(6, indexOf("hello world", "world"));
1987 assertEquals(0, indexOf("hello world", "hello"));
1988 assertEquals(2, indexOf("hello world", "llo"));
1989 assertEquals(-1, indexOf("hello world", "xyz"));
1990 assertEquals(-1, indexOf((String)null, "test"));
1991 assertEquals(-1, indexOf("test", (String)null));
1992 assertEquals(-1, indexOf((String)null, (String)null));
1993 assertEquals(0, indexOf("hello", "hello"));
1994 assertEquals(-1, indexOf("hello", "hello world"));
1995 }
1996
1997
1998
1999
2000 @Test
2001 void a073_indexOfChars() {
2002
2003 assertEquals(-1, indexOf(null, 'a'));
2004 assertEquals(-1, indexOf(null, 'a', 'b'));
2005
2006
2007 assertEquals(0, indexOf("abc", 'a'));
2008 assertEquals(1, indexOf("abc", 'b'));
2009 assertEquals(2, indexOf("abc", 'c'));
2010 assertEquals(-1, indexOf("abc", 'x'));
2011
2012
2013 assertEquals(0, indexOf("abc", 'a', 'b', 'c'));
2014 assertEquals(1, indexOf("abc", 'x', 'b', 'y'));
2015 assertEquals(0, indexOf("abc", 'b', 'a', 'c'));
2016
2017
2018 assertEquals(-1, indexOf("abc", 'x', 'y', 'z'));
2019
2020
2021 assertEquals(-1, indexOf("", 'a'));
2022
2023
2024 assertEquals(0, indexOf("abab", 'a', 'b'));
2025 }
2026
2027
2028
2029
2030 @Test
2031 void a074_indexOfIgnoreCase() {
2032 assertEquals(6, indexOfIgnoreCase("Hello World", "world"));
2033 assertEquals(6, indexOfIgnoreCase("Hello World", "WORLD"));
2034 assertEquals(0, indexOfIgnoreCase("Hello World", "hello"));
2035 assertEquals(0, indexOfIgnoreCase("Hello World", "HELLO"));
2036 assertEquals(2, indexOfIgnoreCase("Hello World", "LLO"));
2037 assertEquals(-1, indexOfIgnoreCase("Hello World", "xyz"));
2038 assertEquals(-1, indexOfIgnoreCase(null, "test"));
2039 assertEquals(-1, indexOfIgnoreCase("test", null));
2040 assertEquals(-1, indexOfIgnoreCase(null, null));
2041 }
2042
2043
2044
2045
2046 @Test
2047 void a075_intern() {
2048
2049 var s1 = new String("test");
2050 var s2 = new String("test");
2051 assertTrue(s1 != s2);
2052
2053 var i1 = intern(s1);
2054 var i2 = intern(s2);
2055 assertTrue(i1 == i2);
2056
2057
2058 assertNull(intern(null));
2059
2060
2061 assertEquals("test", intern("test"));
2062 }
2063
2064
2065
2066
2067 @Test
2068 void a076_interpolate() {
2069 var vars = new HashMap<String,Object>();
2070 vars.put("name", "John");
2071 vars.put("age", 30);
2072 vars.put("city", "New York");
2073
2074 assertEquals("Hello John, you are 30 years old", interpolate("Hello ${name}, you are ${age} years old", vars));
2075 assertEquals("Welcome to New York", interpolate("Welcome to ${city}", vars));
2076 assertEquals("Hello ${unknown}", interpolate("Hello ${unknown}", vars));
2077 assertEquals("No placeholders", interpolate("No placeholders", vars));
2078 assertNull(interpolate(null, vars));
2079 assertEquals("Template", interpolate("Template", null));
2080 assertEquals("Template", interpolate("Template", new HashMap<>()));
2081
2082
2083 var varsWithNull = new HashMap<String,Object>();
2084 varsWithNull.put("name", "John");
2085 varsWithNull.put("value", null);
2086 assertEquals("Hello John, value: null", interpolate("Hello ${name}, value: ${value}", varsWithNull));
2087
2088
2089 assertEquals("John is 30 and lives in New York", interpolate("${name} is ${age} and lives in ${city}", vars));
2090
2091
2092 assertEquals("Hello ${name", interpolate("Hello ${name", vars));
2093 assertEquals("Start ${var1 middle ${var2", interpolate("Start ${var1 middle ${var2", vars));
2094 }
2095
2096
2097
2098
2099 @Test
2100 void a077_isAbsoluteUri() {
2101 assertFalse(isAbsoluteUri(null));
2102 assertFalse(isAbsoluteUri(""));
2103 assertTrue(isAbsoluteUri("http://foo"));
2104 assertTrue(isAbsoluteUri("x://x"));
2105 assertFalse(isAbsoluteUri("xX://x"));
2106 assertFalse(isAbsoluteUri("x ://x"));
2107 assertFalse(isAbsoluteUri("x: //x"));
2108 assertFalse(isAbsoluteUri("x:/ /x"));
2109 assertFalse(isAbsoluteUri("x:x//x"));
2110 assertFalse(isAbsoluteUri("x:/x/x"));
2111 assertTrue(isAbsoluteUri("https://example.com"));
2112 assertTrue(isAbsoluteUri("ftp://server.com"));
2113
2114
2115
2116 assertFalse(isAbsoluteUri("1http://foo")); // Starts with number
2117 assertFalse(isAbsoluteUri(" http://foo")); // Starts with space
2118 assertFalse(isAbsoluteUri("Hhttp://foo")); // Starts with uppercase (not in 'a'-'z' range)
2119
2120
2121 assertFalse(isAbsoluteUri("http1://foo")); // Number after 'http' (not a letter, not ':')
2122 assertFalse(isAbsoluteUri("http@://foo")); // '@' after 'http' (not a letter, not ':')
2123 assertFalse(isAbsoluteUri("http /://foo")); // Space after 'http' (not a letter, not ':')
2124 assertFalse(isAbsoluteUri("http{://foo")); // '{' after 'http' (greater than 'z')
2125
2126
2127 assertFalse(isAbsoluteUri("http:x://foo")); // 'x' instead of '/'
2128 assertFalse(isAbsoluteUri("http:://foo")); // ':' instead of '/'
2129
2130
2131 assertFalse(isAbsoluteUri("http:/x://foo")); // 'x' instead of second '/'
2132 assertFalse(isAbsoluteUri("http:/://foo")); // ':' instead of second '/'
2133
2134
2135
2136
2137 assertFalse(isAbsoluteUri("http"));
2138 assertFalse(isAbsoluteUri("http:"));
2139 assertFalse(isAbsoluteUri("http:/"));
2140 }
2141
2142
2143
2144
2145 @Test
2146 void a078_isAllNotBlank() {
2147 assertFalse(isAllNotBlank());
2148 assertFalse(isAllNotBlank((String)null));
2149 assertFalse(isAllNotBlank(null, null));
2150 assertFalse(isAllNotBlank("", ""));
2151 assertFalse(isAllNotBlank(" ", " "));
2152 assertFalse(isAllNotBlank(null, "hello"));
2153 assertFalse(isAllNotBlank("", " "));
2154 assertFalse(isAllNotBlank("hello", " "));
2155 assertTrue(isAllNotBlank("hello"));
2156 assertTrue(isAllNotBlank("hello", "world"));
2157 assertTrue(isAllNotBlank("hello", "world", "test"));
2158
2159
2160 assertFalse(isAllNotBlank((CharSequence[])null));
2161 assertFalse(isAllNotBlank(new CharSequence[0]));
2162 }
2163
2164
2165
2166
2167 @Test
2168 void a079_isAllNotEmpty() {
2169 assertFalse(isAllNotEmpty());
2170 assertFalse(isAllNotEmpty((String)null));
2171 assertFalse(isAllNotEmpty(null, null));
2172 assertFalse(isAllNotEmpty("", ""));
2173 assertFalse(isAllNotEmpty(null, "hello"));
2174 assertFalse(isAllNotEmpty("", " "));
2175 assertTrue(isAllNotEmpty("hello"));
2176 assertTrue(isAllNotEmpty("hello", "world"));
2177 assertTrue(isAllNotEmpty("hello", " "));
2178 assertTrue(isAllNotEmpty("hello", "world", "test"));
2179
2180
2181 assertFalse(isAllNotEmpty((CharSequence[])null));
2182 assertFalse(isAllNotEmpty(new CharSequence[0]));
2183 }
2184
2185
2186
2187
2188 @Test
2189 void a080_isAlpha() {
2190 assertFalse(isAlpha(null));
2191 assertFalse(isAlpha(""));
2192 assertTrue(isAlpha("abc"));
2193 assertTrue(isAlpha("ABC"));
2194 assertTrue(isAlpha("AbCdEf"));
2195 assertFalse(isAlpha("abc123"));
2196 assertFalse(isAlpha("abc def"));
2197 assertFalse(isAlpha("abc-def"));
2198 assertFalse(isAlpha("123"));
2199 assertTrue(isAlpha("abcdefghijklmnopqrstuvwxyz"));
2200 assertTrue(isAlpha("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
2201 }
2202
2203
2204
2205
2206 @Test
2207 void a081_isAlphaNumeric() {
2208 assertFalse(isAlphaNumeric(null));
2209 assertFalse(isAlphaNumeric(""));
2210 assertTrue(isAlphaNumeric("abc"));
2211 assertTrue(isAlphaNumeric("123"));
2212 assertTrue(isAlphaNumeric("abc123"));
2213 assertTrue(isAlphaNumeric("ABC123"));
2214 assertTrue(isAlphaNumeric("a1b2c3"));
2215 assertFalse(isAlphaNumeric("abc def"));
2216 assertFalse(isAlphaNumeric("abc-123"));
2217 assertFalse(isAlphaNumeric("abc_123"));
2218 assertFalse(isAlphaNumeric("abc.123"));
2219 assertTrue(isAlphaNumeric("abcdefghijklmnopqrstuvwxyz0123456789"));
2220 }
2221
2222
2223
2224
2225 @Test
2226 void a082_isAnyNotBlank() {
2227 assertFalse(isAnyNotBlank());
2228 assertFalse(isAnyNotBlank((String)null));
2229 assertFalse(isAnyNotBlank(null, null));
2230 assertFalse(isAnyNotBlank("", ""));
2231 assertFalse(isAnyNotBlank(" ", " "));
2232 assertTrue(isAnyNotBlank(null, "hello"));
2233 assertTrue(isAnyNotBlank("", "hello"));
2234 assertTrue(isAnyNotBlank(" ", "hello"));
2235 assertTrue(isAnyNotBlank("hello"));
2236 assertTrue(isAnyNotBlank("hello", "world"));
2237 assertTrue(isAnyNotBlank("hello", null, ""));
2238
2239
2240 assertFalse(isAnyNotBlank((CharSequence[])null));
2241 }
2242
2243
2244
2245
2246 @Test
2247 void a083_isAnyNotEmpty() {
2248 assertFalse(isAnyNotEmpty());
2249 assertFalse(isAnyNotEmpty((String)null));
2250 assertFalse(isAnyNotEmpty(null, null));
2251 assertFalse(isAnyNotEmpty("", ""));
2252 assertTrue(isAnyNotEmpty(null, "hello"));
2253 assertTrue(isAnyNotEmpty("", "hello"));
2254 assertTrue(isAnyNotEmpty(" ", "hello"));
2255 assertTrue(isAnyNotEmpty("hello"));
2256 assertTrue(isAnyNotEmpty("hello", "world"));
2257 assertTrue(isAnyNotEmpty("hello", null, ""));
2258
2259
2260 assertFalse(isAnyNotEmpty((CharSequence[])null));
2261 }
2262
2263
2264
2265
2266 @Test
2267 void a084_isBlank() {
2268 assertTrue(isBlank(null));
2269 assertTrue(isBlank(""));
2270 assertTrue(isBlank(" "));
2271 assertTrue(isBlank("\t\n"));
2272 assertTrue(isBlank("\r\n\t "));
2273 assertFalse(isBlank("hello"));
2274 assertFalse(isBlank(" hello "));
2275 assertFalse(isBlank("a"));
2276 }
2277
2278
2279
2280
2281 @Test
2282 void a085_isCreditCard() {
2283
2284 assertTrue(isCreditCard("4532015112830366"));
2285 assertTrue(isCreditCard("4532-0151-1283-0366"));
2286 assertTrue(isCreditCard("4532 0151 1283 0366"));
2287
2288
2289 assertFalse(isCreditCard(null));
2290 assertFalse(isCreditCard(""));
2291 assertFalse(isCreditCard("1234567890"));
2292 assertFalse(isCreditCard("12345678901234567890"));
2293 assertFalse(isCreditCard("1234567890123"));
2294 assertFalse(isCreditCard("abc1234567890"));
2295 }
2296
2297
2298
2299
2300 @Test
2301 void a086_isDecimal() {
2302 var valid = a("+1", "-1", "0x123", "0X123", "0xdef", "0XDEF", "#def", "#DEF", "0123", "123", "0");
2303 for (var s : valid)
2304 assertTrue(isDecimal(s), "Should be valid: " + s);
2305
2306 var invalid = a(null, "", "a", "+", "-", ".", "0xdeg", "0XDEG", "#deg", "#DEG", "0128", "012A");
2307 for (var s : invalid)
2308 assertFalse(isDecimal(s), "Should be invalid: " + s);
2309 }
2310
2311
2312
2313
2314 @Test
2315 void a087_isDigit() {
2316 assertFalse(isDigit(null));
2317 assertFalse(isDigit(""));
2318 assertTrue(isDigit("123"));
2319 assertTrue(isDigit("0"));
2320 assertTrue(isDigit("999"));
2321 assertTrue(isDigit("0123456789"));
2322 assertFalse(isDigit("abc"));
2323 assertFalse(isDigit("abc123"));
2324 assertFalse(isDigit("12.3"));
2325 assertFalse(isDigit("12-3"));
2326 assertFalse(isDigit(" 123"));
2327 assertFalse(isDigit("123 "));
2328 }
2329
2330
2331
2332
2333 @Test
2334 void a088_isEmail() {
2335
2336 assertTrue(isEmail("user@example.com"));
2337 assertTrue(isEmail("test.email@example.com"));
2338 assertTrue(isEmail("user+tag@example.com"));
2339 assertTrue(isEmail("user_name@example.com"));
2340 assertTrue(isEmail("user-name@example.com"));
2341 assertTrue(isEmail("user123@example.com"));
2342 assertTrue(isEmail("user@example.co.uk"));
2343 assertTrue(isEmail("user@subdomain.example.com"));
2344 assertTrue(isEmail("a@b.co"));
2345 assertTrue(isEmail("user.name+tag+sorting@example.com"));
2346
2347
2348 assertFalse(isEmail(null));
2349 assertFalse(isEmail(""));
2350 assertFalse(isEmail(" "));
2351 assertFalse(isEmail("invalid"));
2352 assertFalse(isEmail("@example.com"));
2353 assertFalse(isEmail("user@"));
2354 assertFalse(isEmail("user@example"));
2355 assertFalse(isEmail("user @example.com"));
2356 assertFalse(isEmail("user@example .com"));
2357 }
2358
2359
2360
2361
2362 @Test
2363 void a089_isEmpty() {
2364 assertTrue(StringUtils.isEmpty(null));
2365 assertTrue(StringUtils.isEmpty(""));
2366 assertFalse(StringUtils.isEmpty(" "));
2367 assertFalse(StringUtils.isEmpty("a"));
2368 assertFalse(StringUtils.isEmpty("hello"));
2369 assertFalse(StringUtils.isEmpty(" "));
2370 }
2371
2372
2373
2374
2375 @Test
2376 void a090_isFirstNumberChar() {
2377
2378 assertTrue(isFirstNumberChar('0'));
2379 assertTrue(isFirstNumberChar('1'));
2380 assertTrue(isFirstNumberChar('9'));
2381 assertTrue(isFirstNumberChar('+'));
2382 assertTrue(isFirstNumberChar('-'));
2383 assertTrue(isFirstNumberChar('.'));
2384 assertTrue(isFirstNumberChar('#'));
2385
2386
2387 assertFalse(isFirstNumberChar('a'));
2388 assertFalse(isFirstNumberChar('x'));
2389 assertFalse(isFirstNumberChar(' '));
2390 assertFalse(isFirstNumberChar('('));
2391 }
2392
2393
2394
2395
2396 @Test
2397 void a091_isFloat() {
2398 var valid = a("+1.0", "-1.0", ".0", "NaN", "Infinity", "1e1", "-1e-1", "+1e+1", "-1.1e-1", "+1.1e+1", "1.1f", "1.1F", "1.1d", "1.1D", "0x1.fffffffffffffp1023", "0x1.FFFFFFFFFFFFFP1023", "1.0",
2399 "0.5", "123.456");
2400 for (var s : valid)
2401 assertTrue(isFloat(s), "Should be valid: " + s);
2402
2403 var invalid = a(null, "", "a", "+", "-", ".", "a", "+a", "11a");
2404 for (var s : invalid)
2405 assertFalse(isFloat(s), "Should be invalid: " + s);
2406 }
2407
2408
2409
2410
2411 @Test
2412 void a092_isInterned() {
2413 assertFalse(isInterned(null));
2414
2415
2416 var literal = "test";
2417 assertTrue(isInterned(literal));
2418
2419
2420 var s1 = new String("test");
2421 assertFalse(isInterned(s1));
2422
2423
2424 var s2 = intern(s1);
2425 assertTrue(isInterned(s2));
2426 assertSame(s1.intern(), s2);
2427 }
2428
2429
2430
2431
2432 @Test
2433 void a093_isProbablyJson() {
2434
2435 assertTrue(isProbablyJson("{}"));
2436 assertTrue(isProbablyJson("[]"));
2437 assertTrue(isProbablyJson("'test'"));
2438 assertTrue(isProbablyJson("true"));
2439 assertTrue(isProbablyJson("false"));
2440 assertTrue(isProbablyJson("null"));
2441 assertTrue(isProbablyJson("123"));
2442 assertTrue(isProbablyJson("123.45"));
2443 assertTrue(isProbablyJson(" {} "));
2444 assertTrue(isProbablyJson(" [] "));
2445
2446
2447
2448
2449 assertFalse(isProbablyJson(null));
2450 assertFalse(isProbablyJson(""));
2451 assertFalse(isProbablyJson("abc"));
2452 assertFalse(isProbablyJson("{"));
2453 assertFalse(isProbablyJson("}"));
2454 assertFalse(isProbablyJson("["));
2455 assertFalse(isProbablyJson("]"));
2456 assertFalse(isProbablyJson("'abc"));
2457 assertFalse(isProbablyJson("abc'"));
2458 }
2459
2460
2461
2462
2463 @Test
2464 void a094_isProbablyJsonArray() {
2465
2466 assertTrue(isProbablyJsonArray("[]", false));
2467 assertTrue(isProbablyJsonArray("[1,2,3]", false));
2468 assertTrue(isProbablyJsonArray(" [1,2,3] ", true));
2469 assertTrue(isProbablyJsonArray("/*comment*/ [1,2,3] /*comment*/", true));
2470
2471
2472 assertTrue(isProbablyJsonArray("//comment\n [1,2,3]", true)); // With // comment ending in newline
2473
2474 assertFalse(isProbablyJsonArray("//comment [1,2,3]", true)); // With // comment, no newline - consumes everything
2475 assertTrue(isProbablyJsonArray(" //comment\n [1,2,3] ", true)); // With // comment and whitespace
2476
2477
2478 assertFalse(isProbablyJsonArray(null, false));
2479 assertFalse(isProbablyJsonArray("", false));
2480 assertFalse(isProbablyJsonArray("{}", false));
2481 assertFalse(isProbablyJsonArray("123", false));
2482 assertFalse(isProbablyJsonArray("[", false));
2483 assertFalse(isProbablyJsonArray("]", false));
2484
2485
2486
2487 assertFalse(isProbablyJsonArray(" {1,2,3} ", true));
2488 assertFalse(isProbablyJsonArray(" /*comment*/ {1,2,3} ", true));
2489
2490
2491 assertFalse(isProbablyJsonArray(" [1,2,3 ", true));
2492 assertFalse(isProbablyJsonArray(" /*comment*/ [1,2,3 ", true));
2493
2494
2495 assertTrue(isProbablyJsonArray(" [1,2,3] ", true));
2496 assertTrue(isProbablyJsonArray(" /*comment*/ [1,2,3] /*comment*/ ", true));
2497
2498
2499 assertTrue(isProbablyJsonArray(" [1,2,3] //comment\n ", true)); // Valid, // comment with newline
2500
2501
2502 assertTrue(isProbablyJsonArray(" [1,2,3] //comment", true)); // Valid, // comment ending at EOF
2503 assertFalse(isProbablyJsonArray(" [1,2,3] extra ", true));
2504 assertFalse(isProbablyJsonArray(" /*comment*/ [1,2,3] extra /*comment*/ ", true));
2505 }
2506
2507
2508
2509
2510 @Test
2511 void a095_isProbablyJsonObject() {
2512
2513 assertTrue(isProbablyJsonObject("{foo:'bar'}", true));
2514 assertTrue(isProbablyJsonObject(" { foo:'bar' } ", true));
2515 assertTrue(isProbablyJsonObject("/*foo*/ { foo:'bar' } /*foo*/", true));
2516
2517
2518 assertTrue(isProbablyJsonObject("//comment\n { foo:'bar' }", true)); // With // comment ending in newline
2519
2520 assertFalse(isProbablyJsonObject("//comment { foo:'bar' }", true)); // With // comment, no newline - consumes everything
2521 assertTrue(isProbablyJsonObject(" //comment\n { foo:'bar' } ", true)); // With // comment and whitespace
2522 assertTrue(isProbablyJsonObject("{}", false));
2523 assertTrue(isProbablyJsonObject("{'key':'value'}", false));
2524
2525
2526 assertFalse(isProbablyJsonObject(null, false));
2527 assertFalse(isProbablyJsonObject("", false));
2528 assertFalse(isProbablyJsonObject(" { foo:'bar' ", true));
2529 assertFalse(isProbablyJsonObject(" foo:'bar' } ", true));
2530 assertFalse(isProbablyJsonObject("[]", false));
2531 assertFalse(isProbablyJsonObject("123", false));
2532
2533
2534 assertTrue(isProbablyJsonObject("{}", false));
2535 assertTrue(isProbablyJsonObject("{key:value}", false));
2536 assertFalse(isProbablyJsonObject(" {} ", false));
2537 assertFalse(isProbablyJsonObject("[]", false));
2538 assertFalse(isProbablyJsonObject("{", false));
2539 assertFalse(isProbablyJsonObject("}", false));
2540 assertFalse(isProbablyJsonObject("x", false));
2541
2542
2543 assertTrue(isProbablyJsonObject(" {} ", true));
2544 assertTrue(isProbablyJsonObject(" /*comment*/ {key:value} /*comment*/ ", true));
2545
2546
2547 assertTrue(isProbablyJsonObject(" {key:value} //comment\n ", true)); // Valid, // comment with newline
2548
2549
2550 assertTrue(isProbablyJsonObject(" {key:value} //comment", true)); // Valid, // comment ending at EOF
2551 assertFalse(isProbablyJsonObject(" {key:value} extra ", true));
2552 assertFalse(isProbablyJsonObject(" /*comment*/ {key:value} extra /*comment*/ ", true));
2553
2554
2555 assertFalse(isProbablyJsonObject(123, true));
2556 assertFalse(isProbablyJsonObject(new Object(), false));
2557 }
2558
2559
2560
2561
2562 @Test
2563 void a096_isNotBlank() {
2564 assertFalse(isNotBlank(null));
2565 assertFalse(isNotBlank(""));
2566 assertFalse(isNotBlank(" "));
2567 assertFalse(isNotBlank("\t\n"));
2568 assertFalse(isNotBlank("\r\n\t "));
2569 assertTrue(isNotBlank("hello"));
2570 assertTrue(isNotBlank(" hello "));
2571 assertTrue(isNotBlank("a"));
2572 }
2573
2574
2575
2576
2577 @Test
2578 void a097_isNumberChar() {
2579
2580 assertTrue(isNumberChar('0'));
2581 assertTrue(isNumberChar('1'));
2582 assertTrue(isNumberChar('9'));
2583 assertTrue(isNumberChar('+'));
2584 assertTrue(isNumberChar('-'));
2585 assertTrue(isNumberChar('.'));
2586 assertTrue(isNumberChar('x'));
2587 assertTrue(isNumberChar('X'));
2588 assertTrue(isNumberChar('#'));
2589 assertTrue(isNumberChar('p'));
2590 assertTrue(isNumberChar('P'));
2591 assertTrue(isNumberChar('a'));
2592 assertTrue(isNumberChar('f'));
2593 assertTrue(isNumberChar('A'));
2594 assertTrue(isNumberChar('F'));
2595
2596
2597 assertFalse(isNumberChar('g'));
2598 assertFalse(isNumberChar('G'));
2599 assertFalse(isNumberChar(' '));
2600 assertFalse(isNumberChar('('));
2601 }
2602
2603
2604
2605
2606 @Test
2607 void a098_isNumeric() {
2608
2609 assertTrue(isNumeric("123"));
2610 assertTrue(isNumeric("0x123"));
2611 assertTrue(isNumeric("0.123"));
2612 assertTrue(isNumeric("+123"));
2613 assertTrue(isNumeric("-123"));
2614 assertTrue(isNumeric("#123"));
2615 assertTrue(isNumeric("0123"));
2616 assertTrue(isNumeric("1.23"));
2617 assertTrue(isNumeric("1e1"));
2618
2619
2620
2621
2622 assertFalse(isNumeric(null));
2623 assertFalse(isNumeric(""));
2624 assertFalse(isNumeric("x"));
2625 assertFalse(isNumeric("x123"));
2626 assertFalse(isNumeric("0x123x"));
2627 assertFalse(isNumeric("0.123.4"));
2628 assertFalse(isNumeric("abc"));
2629 assertFalse(isNumeric("NaN"));
2630 assertFalse(isNumeric("Infinity"));
2631 }
2632
2633
2634
2635
2636
2637 @Test
2638 void a099_isNumeric_parseNumber() {
2639
2640 assertFalse(isNumeric(null));
2641 assertFalse(isNumeric(""));
2642 assertFalse(isNumeric("x"));
2643 assertFalse(isNumeric("x123"));
2644 assertFalse(isNumeric("0x123x"));
2645 assertFalse(isNumeric("0.123.4"));
2646 assertFalse(isNumeric("214748364x"));
2647 assertFalse(isNumeric("2147483640x"));
2648
2649
2650 assertTrue(isNumeric("123"));
2651 assertEquals(123, parseNumber("123", null));
2652 assertEquals(123, parseNumber("123", Integer.class));
2653 assertEquals((short)123, parseNumber("123", Short.class));
2654 assertEquals((long)123, parseNumber("123", Long.class));
2655
2656 assertTrue(isNumeric("0123"));
2657 assertEquals(0123, parseNumber("0123", null));
2658
2659 assertTrue(isNumeric("-0123"));
2660 assertEquals(-0123, parseNumber("-0123", null));
2661
2662
2663 assertTrue(isNumeric("0x123"));
2664 assertEquals(0x123, parseNumber("0x123", null));
2665
2666 assertTrue(isNumeric("-0x123"));
2667 assertEquals(-0x123, parseNumber("-0x123", null));
2668
2669 assertTrue(isNumeric("0X123"));
2670 assertEquals(0X123, parseNumber("0X123", null));
2671
2672 assertTrue(isNumeric("-0X123"));
2673 assertEquals(-0X123, parseNumber("-0X123", null));
2674
2675 assertTrue(isNumeric("#123"));
2676 assertEquals(0x123, parseNumber("#123", null));
2677
2678 assertTrue(isNumeric("-#123"));
2679 assertEquals(-0x123, parseNumber("-#123", null));
2680
2681
2682 assertTrue(isNumeric("0.123"));
2683 assertEquals(0.123f, parseNumber("0.123", null));
2684
2685 assertTrue(isNumeric("-0.123"));
2686 assertEquals(-0.123f, parseNumber("-0.123", null));
2687
2688 assertTrue(isNumeric(".123"));
2689 assertEquals(.123f, parseNumber(".123", null));
2690
2691 assertTrue(isNumeric("-.123"));
2692 assertEquals(-.123f, parseNumber("-.123", null));
2693
2694 assertTrue(isNumeric("0.84370821629078d"));
2695 assertEquals(0.84370821629078d, parseNumber("0.84370821629078d", null));
2696
2697 assertTrue(isNumeric("84370821629078.8437d"));
2698 assertEquals(84370821629078.8437d, parseNumber("84370821629078.8437d", null));
2699
2700 assertTrue(isNumeric("0.16666666666666666d"));
2701 assertEquals(0.16666666666666666d, parseNumber("0.16666666666666666d", null));
2702
2703 assertTrue(isNumeric("0.16666666f"));
2704 assertEquals(0.16666666f, parseNumber("0.16666666f", null));
2705
2706 assertTrue(isNumeric("0.16666666d"));
2707 assertEquals(0.16666666f, parseNumber("0.16666666d", null));
2708
2709 assertTrue(isNumeric("3.140000000000000124344978758017532527446746826171875d"));
2710 assertEquals(3.14f, parseNumber("3.140000000000000124344978758017532527446746826171875d", null));
2711
2712 assertTrue(isNumeric("12345.678f"));
2713 assertEquals(1.2345678e4f, parseNumber("12345.678f", null));
2714
2715
2716 assertTrue(isNumeric("1e1"));
2717 assertEquals(1e1f, parseNumber("1e1", null));
2718
2719 assertTrue(isNumeric("1e+1"));
2720 assertEquals(1e+1f, parseNumber("1e+1", null));
2721
2722 assertTrue(isNumeric("1e-1"));
2723 assertEquals(1e-1f, parseNumber("1e-1", null));
2724
2725 assertTrue(isNumeric("1.1e1"));
2726 assertEquals(1.1e1f, parseNumber("1.1e1", null));
2727
2728 assertTrue(isNumeric("1.1e+1"));
2729 assertEquals(1.1e+1f, parseNumber("1.1e+1", null));
2730
2731 assertTrue(isNumeric("1.1e-1"));
2732 assertEquals(1.1e-1f, parseNumber("1.1e-1", null));
2733
2734 assertTrue(isNumeric(".1e1"));
2735 assertEquals(.1e1f, parseNumber(".1e1", null));
2736
2737 assertTrue(isNumeric(".1e+1"));
2738 assertEquals(.1e+1f, parseNumber(".1e+1", null));
2739
2740 assertTrue(isNumeric(".1e-1"));
2741 assertEquals(.1e-1f, parseNumber(".1e-1", null));
2742
2743
2744 assertTrue(isNumeric("0x123e1"));
2745 assertEquals(0x123e1, parseNumber("0x123e1", null));
2746
2747
2748 var s = "-2147483648";
2749 assertTrue(isNumeric(s));
2750 assertTrue(parseNumber(s, null) instanceof Integer);
2751 assertEquals(-2147483648, parseNumber(s, null));
2752
2753 s = "2147483647";
2754 assertTrue(isNumeric(s));
2755 assertTrue(parseNumber(s, null) instanceof Integer);
2756 assertEquals(2147483647, parseNumber(s, null));
2757
2758 s = "-2147483649";
2759 assertTrue(isNumeric(s));
2760 assertTrue(parseNumber(s, null) instanceof Long);
2761 assertEquals(-2147483649L, parseNumber(s, null));
2762
2763 s = "2147483648";
2764 assertTrue(isNumeric(s));
2765 assertTrue(parseNumber(s, null) instanceof Long);
2766 assertEquals(2147483648L, parseNumber(s, null));
2767
2768
2769 s = "-9223372036854775808";
2770 assertTrue(isNumeric(s));
2771 assertTrue(parseNumber(s, null) instanceof Long);
2772 assertEquals(-9223372036854775808L, parseNumber(s, null));
2773
2774 s = "9223372036854775807";
2775 assertTrue(isNumeric(s));
2776 assertTrue(parseNumber(s, null) instanceof Long);
2777 assertEquals(9223372036854775807L, parseNumber(s, null));
2778
2779
2780 s = "-9223372036854775809";
2781 assertTrue(isNumeric(s));
2782 assertTrue(parseNumber(s, null) instanceof Double);
2783 assertEquals(-9223372036854775808L, parseNumber(s, null).longValue());
2784 assertEquals(-9.223372036854776E18, parseNumber(s, null));
2785
2786 s = "9223372036854775808";
2787 assertTrue(isNumeric(s));
2788 assertTrue(parseNumber(s, null) instanceof Double);
2789 assertEquals(9223372036854775807L, parseNumber(s, null).longValue());
2790 assertEquals(9.223372036854776E18, parseNumber(s, null));
2791
2792
2793 s = "-123456789012345678901";
2794 assertTrue(isNumeric(s));
2795 assertTrue(parseNumber(s, null) instanceof Double);
2796 assertEquals(-9223372036854775808L, parseNumber(s, null).longValue());
2797 assertEquals(-1.2345678901234568E20, parseNumber(s, null));
2798
2799 s = "123456789012345678901";
2800 assertTrue(isNumeric(s));
2801 assertTrue(parseNumber(s, null) instanceof Double);
2802 assertEquals(9223372036854775807L, parseNumber(s, null).longValue());
2803 assertEquals(1.2345678901234568E20, parseNumber(s, null));
2804
2805
2806 s = String.valueOf(Float.MAX_VALUE / 2);
2807 assertTrue(isNumeric(s));
2808 assertTrue(parseNumber(s, null) instanceof Float);
2809 assertEquals(1.7014117E38f, parseNumber(s, null));
2810
2811 s = String.valueOf((-Float.MAX_VALUE) / 2);
2812 assertTrue(isNumeric(s));
2813 assertTrue(parseNumber(s, null) instanceof Float);
2814 assertEquals(-1.7014117E38f, parseNumber(s, null));
2815
2816 s = String.valueOf((double)Float.MAX_VALUE * 2);
2817 assertTrue(isNumeric(s));
2818 assertTrue(parseNumber(s, null) instanceof Double);
2819 assertEquals("6.805646932770577E38", parseNumber(s, null).toString());
2820
2821 s = String.valueOf((double)Float.MAX_VALUE * -2);
2822 assertTrue(isNumeric(s));
2823 assertTrue(parseNumber(s, null) instanceof Double);
2824 assertEquals("-6.805646932770577E38", parseNumber(s, null).toString());
2825
2826
2827 var ai1 = parseNumber("123", AtomicInteger.class);
2828 assertTrue(ai1 instanceof AtomicInteger);
2829 assertEquals(123, ((AtomicInteger)ai1).get());
2830
2831 var ai2 = parseNumber("-456", AtomicInteger.class);
2832 assertTrue(ai2 instanceof AtomicInteger);
2833 assertEquals(-456, ((AtomicInteger)ai2).get());
2834
2835 var ai3 = parseNumber("0x10", AtomicInteger.class);
2836 assertTrue(ai3 instanceof AtomicInteger);
2837 assertEquals(16, ((AtomicInteger)ai3).get());
2838
2839 var al1 = parseNumber("123", AtomicLong.class);
2840 assertTrue(al1 instanceof AtomicLong);
2841 assertEquals(123L, ((AtomicLong)al1).get());
2842
2843 var al2 = parseNumber("-456", AtomicLong.class);
2844 assertTrue(al2 instanceof AtomicLong);
2845 assertEquals(-456L, ((AtomicLong)al2).get());
2846
2847 var al3 = parseNumber("9223372036854775807", AtomicLong.class);
2848 assertTrue(al3 instanceof AtomicLong);
2849 assertEquals(9223372036854775807L, ((AtomicLong)al3).get());
2850
2851 var al4 = parseNumber("0x10", AtomicLong.class);
2852 assertTrue(al4 instanceof AtomicLong);
2853 assertEquals(16L, ((AtomicLong)al4).get());
2854
2855
2856 assertEquals(1000000, parseNumber("1_000_000", Integer.class));
2857 assertEquals(1234567, parseNumber("1_234_567", Integer.class));
2858 assertEquals(-1000000, parseNumber("-1_000_000", Integer.class));
2859
2860 assertEquals(1000000L, parseNumber("1_000_000", Long.class));
2861 assertEquals(9223372036854775807L, parseNumber("9_223_372_036_854_775_807", Long.class));
2862 assertEquals(-9223372036854775808L, parseNumber("-9_223_372_036_854_775_808", Long.class));
2863
2864 assertEquals((short)32767, parseNumber("32_767", Short.class));
2865 assertEquals((short)-32768, parseNumber("-32_768", Short.class));
2866
2867 assertEquals((byte)127, parseNumber("1_27", Byte.class));
2868 assertEquals((byte)-128, parseNumber("-1_28", Byte.class));
2869
2870 assertEquals(1000.5f, parseNumber("1_000.5", Float.class));
2871 assertEquals(1234567.89f, parseNumber("1_234_567.89", Float.class));
2872
2873 assertEquals(1000.5, parseNumber("1_000.5", Double.class));
2874 assertEquals(1234567.89, parseNumber("1_234_567.89", Double.class));
2875
2876 var bi1 = parseNumber("1_000_000_000_000_000_000_000", BigInteger.class);
2877 assertTrue(bi1 instanceof BigInteger);
2878 assertEquals(new BigInteger("1000000000000000000000"), bi1);
2879
2880 var bi2 = parseNumber("-9_223_372_036_854_775_809", BigInteger.class);
2881 assertTrue(bi2 instanceof BigInteger);
2882 assertEquals(new BigInteger("-9223372036854775809"), bi2);
2883
2884 var bd1 = parseNumber("1_234_567.89", BigDecimal.class);
2885 assertTrue(bd1 instanceof BigDecimal);
2886 assertEquals(new BigDecimal("1234567.89"), bd1);
2887
2888 var bd2 = parseNumber("-1_000_000.123_456", BigDecimal.class);
2889 assertTrue(bd2 instanceof BigDecimal);
2890 assertEquals(new BigDecimal("-1000000.123456"), bd2);
2891
2892 var ai4 = parseNumber("1_000_000", AtomicInteger.class);
2893 assertTrue(ai4 instanceof AtomicInteger);
2894 assertEquals(1000000, ((AtomicInteger)ai4).get());
2895
2896 var al5 = parseNumber("9_223_372_036_854_775_807", AtomicLong.class);
2897 assertTrue(al5 instanceof AtomicLong);
2898 assertEquals(9223372036854775807L, ((AtomicLong)al5).get());
2899
2900 assertEquals(0x12345678, parseNumber("0x12_34_56_78", Integer.class));
2901 assertEquals(0x1234567890ABCDEFL, parseNumber("0x12_34_56_78_90_AB_CD_EF", Long.class));
2902
2903 assertEquals(1000000, parseNumber("1_000_000", null));
2904 assertEquals(1000000000, parseNumber("1_000_000_000", null));
2905 assertEquals(1000.5f, parseNumber("1_000.5", null));
2906
2907
2908 assertThrows(NumberFormatException.class, () -> parseNumber("x", Number.class));
2909 assertThrows(NumberFormatException.class, () -> parseNumber("x", null));
2910 assertThrowsWithMessage(NumberFormatException.class, "Unsupported Number type", () -> parseNumber("x", BadNumber.class));
2911 assertThrows(NumberFormatException.class, () -> parseNumber("214748364x", Number.class));
2912 assertThrows(NumberFormatException.class, () -> parseNumber("2147483640x", Long.class));
2913 }
2914
2915
2916
2917
2918 @Test
2919 void a100_isOneOf() {
2920 assertTrue(isOneOf("test", "test", "other"));
2921 assertTrue(isOneOf("test", "other", "test"));
2922 assertTrue(isOneOf("test", "test"));
2923 assertFalse(isOneOf("test", "other", "another"));
2924 assertFalse(isOneOf("test", "TEST"));
2925 assertTrue(isOneOf(null, "test", null, "other"));
2926 assertTrue(isOneOf("test", null, "test"));
2927 assertFalse(isOneOf(null, "test", "other"));
2928 }
2929
2930
2931
2932
2933 @Test
2934 void a101_isPhoneNumber() {
2935
2936 assertTrue(isPhoneNumber("1234567890"));
2937 assertTrue(isPhoneNumber("12345678901"));
2938 assertTrue(isPhoneNumber("123456789012345"));
2939 assertTrue(isPhoneNumber("(123) 456-7890"));
2940 assertTrue(isPhoneNumber("123-456-7890"));
2941 assertTrue(isPhoneNumber("123.456.7890"));
2942 assertTrue(isPhoneNumber("123 456 7890"));
2943 assertTrue(isPhoneNumber("+1 123-456-7890"));
2944 assertTrue(isPhoneNumber("+44 20 1234 5678"));
2945 assertTrue(isPhoneNumber("+1 (123) 456-7890"));
2946
2947
2948 assertFalse(isPhoneNumber(null));
2949 assertFalse(isPhoneNumber(""));
2950 assertFalse(isPhoneNumber(" "));
2951 assertFalse(isPhoneNumber("123"));
2952 assertFalse(isPhoneNumber("12345"));
2953 assertFalse(isPhoneNumber("abc1234567"));
2954 assertFalse(isPhoneNumber("1234567890123456"));
2955 }
2956
2957
2958
2959
2960 @Test
2961 void a102_isSimilar() {
2962 assertTrue(isSimilar("hello", "hello", 0.8));
2963 assertTrue(isSimilar("hello", "hello", 1.0));
2964 assertFalse(isSimilar("kitten", "sitting", 0.8));
2965 assertTrue(isSimilar("kitten", "sitting", 0.5));
2966 assertFalse(isSimilar("abc", "xyz", 0.5));
2967 assertTrue(isSimilar("hello", "hallo", 0.8));
2968 assertFalse(isSimilar("hello", "world", 0.8));
2969
2970 assertTrue(isSimilar(null, null, 0.8));
2971 assertFalse(isSimilar("hello", null, 0.8));
2972 assertFalse(isSimilar(null, "hello", 0.8));
2973 }
2974
2975
2976
2977
2978 @Test
2979 void a103_isUri() {
2980
2981 assertTrue(isUri("http://example.com"));
2982 assertTrue(isUri("https://example.com"));
2983 assertTrue(isUri("ftp://server.com"));
2984 assertTrue(isUri("file://path/to/file"));
2985 assertTrue(isUri("ab://test"));
2986 assertTrue(isUri("xyz://test"));
2987
2988
2989 assertFalse(isUri(null));
2990 assertFalse(isUri(""));
2991 assertFalse(isUri("x://x")); // Too short (needs at least 2 chars)
2992 assertFalse(isUri("xX://x")); // Mixed case
2993 assertFalse(isUri("x ://x")); // Space
2994 assertFalse(isUri("x: //x")); // Space after colon
2995 assertFalse(isUri("x:/x/x"));
2996 assertFalse(isUri("C:/temp"));
2997
2998
2999
3000 assertFalse(isUri("1http://foo")); // Starts with number
3001 assertFalse(isUri(" http://foo")); // Starts with space
3002 assertFalse(isUri("Hhttp://foo")); // Starts with uppercase (not in 'a'-'z' range)
3003
3004
3005 assertFalse(isUri("h1ttp://foo")); // Number in protocol
3006 assertFalse(isUri("h ttp://foo")); // Space in protocol
3007
3008
3009
3010
3011 assertFalse(isUri("http1://foo")); // Number after 'http' (not a letter, not ':')
3012 assertFalse(isUri("http/://foo")); // '/' instead of ':' (not a letter, not ':')
3013 assertFalse(isUri("http@://foo")); // '@' instead of ':' (not a letter, not ':')
3014
3015
3016 assertFalse(isUri("http:x://foo")); // 'x' instead of '/'
3017 assertFalse(isUri("http:://foo")); // ':' instead of '/'
3018
3019
3020 assertFalse(isUri("http:"));
3021 assertFalse(isUri("http"));
3022 assertFalse(isUri("ht"));
3023 }
3024
3025
3026
3027
3028 @Test
3029 void a104_isValidDateFormat() {
3030
3031 assertTrue(isValidDateFormat("2023-12-25", "yyyy-MM-dd"));
3032 assertTrue(isValidDateFormat("25/12/2023", "dd/MM/yyyy"));
3033 assertTrue(isValidDateFormat("12/25/2023", "MM/dd/yyyy"));
3034 assertTrue(isValidDateFormat("2023-01-01", "yyyy-MM-dd"));
3035
3036
3037 assertFalse(isValidDateFormat("2023-13-25", "yyyy-MM-dd"));
3038 assertFalse(isValidDateFormat("2023-12-32", "yyyy-MM-dd"));
3039 assertFalse(isValidDateFormat("2023-12-25", "invalid"));
3040 assertFalse(isValidDateFormat("not-a-date", "yyyy-MM-dd"));
3041
3042
3043 assertFalse(isValidDateFormat(null, "yyyy-MM-dd"));
3044 assertFalse(isValidDateFormat("2023-12-25", null));
3045 assertFalse(isValidDateFormat("", "yyyy-MM-dd"));
3046 assertFalse(isValidDateFormat("2023-12-25", ""));
3047 }
3048
3049
3050
3051
3052 @Test
3053 void a105_isValidHostname() {
3054
3055 assertFalse(isValidHostname(null));
3056 assertFalse(isValidHostname(""));
3057 assertFalse(isValidHostname(" "));
3058
3059
3060 assertTrue(isValidHostname("example.com"));
3061 assertTrue(isValidHostname("www.example.com"));
3062 assertTrue(isValidHostname("subdomain.example.com"));
3063 assertTrue(isValidHostname("localhost"));
3064 assertTrue(isValidHostname("a"));
3065 assertTrue(isValidHostname("a-b"));
3066 assertTrue(isValidHostname("a1"));
3067 assertTrue(isValidHostname("example123.com"));
3068
3069
3070 assertFalse(isValidHostname(".example.com"));
3071 assertFalse(isValidHostname("."));
3072
3073
3074 assertFalse(isValidHostname("example.com."));
3075 assertFalse(isValidHostname("example."));
3076
3077
3078 var longLabel = "a".repeat(64) + ".com";
3079 assertFalse(isValidHostname(longLabel));
3080
3081
3082 var longHostname = "a".repeat(63) + "." + "b".repeat(63) + "." + "c".repeat(63) + "." + "d".repeat(64) + ".com";
3083 assertFalse(isValidHostname(longHostname));
3084
3085
3086 assertFalse(isValidHostname("example..com"));
3087 assertFalse(isValidHostname(".."));
3088 assertFalse(isValidHostname("."));
3089
3090
3091 assertFalse(isValidHostname("-example.com"));
3092 assertFalse(isValidHostname("example.-com"));
3093
3094
3095 assertFalse(isValidHostname("example-.com"));
3096 assertFalse(isValidHostname("example.com-"));
3097
3098
3099 assertFalse(isValidHostname("example_com"));
3100 assertFalse(isValidHostname("example.com:80"));
3101 assertFalse(isValidHostname("example com"));
3102 assertFalse(isValidHostname("example@com"));
3103 assertFalse(isValidHostname("example.com/"));
3104 assertFalse(isValidHostname("example.com?"));
3105
3106
3107 assertTrue(isValidHostname("ex-ample.com"));
3108 assertTrue(isValidHostname("my-example-site.com"));
3109
3110
3111 assertTrue(isValidHostname("example123.com"));
3112 assertTrue(isValidHostname("123example.com"));
3113
3114
3115 assertTrue(isValidHostname("a"));
3116 assertTrue(isValidHostname("1"));
3117
3118
3119 var maxLabel = "a".repeat(63) + ".com";
3120 assertTrue(isValidHostname(maxLabel));
3121
3122
3123
3124
3125
3126
3127
3128
3129 }
3130
3131
3132
3133
3134
3135
3136
3137 @Test
3138 void a106_isValidIpAddress() {
3139
3140 assertTrue(isValidIpAddress("192.168.1.1"));
3141 assertTrue(isValidIpAddress("0.0.0.0"));
3142 assertTrue(isValidIpAddress("255.255.255.255"));
3143 assertTrue(isValidIpAddress("127.0.0.1"));
3144
3145
3146 assertFalse(isValidIpAddress("256.1.1.1"));
3147 assertFalse(isValidIpAddress("192.168.1"));
3148 assertFalse(isValidIpAddress("192.168.1.1.1"));
3149 assertFalse(isValidIpAddress("not.an.ip"));
3150 assertFalse(isValidIpAddress("-1.1.1.1"));
3151
3152
3153 assertTrue(isValidIpAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334"));
3154 assertTrue(isValidIpAddress("::1"));
3155 assertTrue(isValidIpAddress("2001:db8::1"));
3156
3157
3158 assertFalse(isValidIpAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334:9999"));
3159 assertFalse(isValidIpAddress("gggg::1"));
3160
3161
3162 assertFalse(isValidIpAddress(null));
3163 assertFalse(isValidIpAddress(""));
3164
3165
3166
3167 assertTrue(isValidIpAddress("192.168.1.1"));
3168 assertFalse(isValidIpAddress("192.168.1"));
3169 assertFalse(isValidIpAddress("192.168.1.1.1"));
3170 assertFalse(isValidIpAddress("256.1.1.1"));
3171 assertFalse(isValidIpAddress("abc."));
3172 assertFalse(isValidIpAddress("192.168.1.1::invalid"));
3173
3174
3175 assertTrue(isValidIpAddress("2001:0db8:85a3::8a2e:0370:7334"));
3176 assertFalse(isValidIpAddress("gggg::1"));
3177
3178
3179 assertFalse(isValidIpAddress("notanip"));
3180 assertFalse(isValidIpAddress("abc"));
3181
3182
3183 assertFalse(isValidIpAddress("192.168.abc.1"));
3184 assertFalse(isValidIpAddress("192.168.1.abc"));
3185 }
3186
3187
3188
3189
3190 @Test
3191 void a107_isValidIPv6Address() {
3192
3193 assertFalse(isValidIPv6Address(null));
3194 assertFalse(isValidIPv6Address(""));
3195
3196
3197 assertTrue(isValidIPv6Address("2001:0db8:85a3:0000:0000:8a2e:0370:7334"));
3198 assertTrue(isValidIPv6Address("2001:0DB8:85A3:0000:0000:8A2E:0370:7334"));
3199 assertTrue(isValidIPv6Address("2001:db8:85a3:0:0:8a2e:370:7334"));
3200
3201
3202 assertTrue(isValidIPv6Address("2001:db8::1"));
3203 assertTrue(isValidIPv6Address("::1"));
3204 assertTrue(isValidIPv6Address("::"));
3205 assertTrue(isValidIPv6Address("2001:db8:85a3::8a2e:0370:7334"));
3206 assertTrue(isValidIPv6Address("2001:db8::8a2e:0370:7334"));
3207 assertTrue(isValidIPv6Address("2001:db8:85a3:0000:0000:8a2e::"));
3208
3209
3210 assertTrue(isValidIPv6Address("::ffff:192.168.1.1"));
3211 assertTrue(isValidIPv6Address("::FFFF:192.168.1.1"));
3212 assertTrue(isValidIPv6Address("::192.168.1.1"));
3213
3214
3215 assertFalse(isValidIPv6Address(":2001:db8::1"));
3216 assertFalse(isValidIPv6Address(":1"));
3217
3218
3219 assertFalse(isValidIPv6Address("2001:db8::1:"));
3220 assertFalse(isValidIPv6Address("1:"));
3221
3222
3223 assertFalse(isValidIPv6Address("192.168.1.1"));
3224
3225
3226 assertFalse(isValidIPv6Address("::ffff:192.168.1"));
3227 assertFalse(isValidIPv6Address("::ffff:192.168.1.1.1"));
3228
3229
3230 assertFalse(isValidIPv6Address("::ffff:256.168.1.1"));
3231 assertFalse(isValidIPv6Address("::ffff:192.256.1.1"));
3232 assertFalse(isValidIPv6Address("::ffff:-1.168.1.1"));
3233
3234
3235 assertFalse(isValidIPv6Address("::ffff:abc.168.1.1"));
3236 assertFalse(isValidIPv6Address("::ffff:192.abc.1.1"));
3237
3238
3239 assertTrue(isValidIPv6Address("::ffff:192.168.1.1"));
3240 assertTrue(isValidIPv6Address("::FFFF:192.168.1.1"));
3241 assertTrue(isValidIPv6Address("::192.168.1.1"));
3242
3243
3244 assertFalse(isValidIPv6Address("2001::db8::1"));
3245 assertFalse(isValidIPv6Address("::1::"));
3246
3247
3248
3249 assertFalse(isValidIPv6Address("2001::db8::1"));
3250
3251
3252
3253
3254 assertFalse(isValidIPv6Address("1:2:3:4:5:6:7:8::9"));
3255
3256 assertFalse(isValidIPv6Address("1:2:3:4:5:6:7::8:9"));
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271 assertFalse(isValidIPv6Address("2001:db8:85a3:0000:0000:8a2e:0370"));
3272 assertFalse(isValidIPv6Address("2001:db8:85a3:0000:0000:8a2e:0370:7334:9999"));
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285 assertFalse(isValidIPv6Address("2001:12345:db8::1"));
3286 assertFalse(isValidIPv6Address("2001:abcdef:db8::1"));
3287
3288
3289 assertFalse(isValidIPv6Address("2001:db8g:85a3::1"));
3290 assertFalse(isValidIPv6Address("2001:db8h:85a3::1"));
3291 assertFalse(isValidIPv6Address("2001:db8z:85a3::1"));
3292 assertFalse(isValidIPv6Address("2001:db8G:85a3::1"));
3293
3294 assertFalse(isValidIPv6Address("2001:db8G:85a3::1"));
3295 assertFalse(isValidIPv6Address("2001:db8@:85a3::1"));
3296 assertFalse(isValidIPv6Address("2001:db8#:85a3::1"));
3297
3298
3299 assertTrue(isValidIPv6Address("1:2:3:4:5:6:7:8"));
3300 assertTrue(isValidIPv6Address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"));
3301 assertTrue(isValidIPv6Address("0:0:0:0:0:0:0:0"));
3302 assertTrue(isValidIPv6Address("::ffff:0.0.0.0"));
3303 assertTrue(isValidIPv6Address("::ffff:255.255.255.255"));
3304 }
3305
3306
3307
3308
3309 @Test
3310 void a107_isValidMacAddress() {
3311
3312 assertTrue(isValidMacAddress("00:1B:44:11:3A:B7"));
3313 assertTrue(isValidMacAddress("00:1b:44:11:3a:b7"));
3314 assertTrue(isValidMacAddress("FF:FF:FF:FF:FF:FF"));
3315
3316
3317 assertTrue(isValidMacAddress("00-1B-44-11-3A-B7"));
3318 assertTrue(isValidMacAddress("00-1b-44-11-3a-b7"));
3319
3320
3321 assertFalse(isValidMacAddress(null));
3322 assertFalse(isValidMacAddress(""));
3323 assertFalse(isValidMacAddress("00:1B:44:11:3A"));
3324 assertFalse(isValidMacAddress("00:1B:44:11:3A:B7:99"));
3325 assertFalse(isValidMacAddress("GG:1B:44:11:3A:B7"));
3326 assertFalse(isValidMacAddress("00 1B 44 11 3A B7"));
3327 }
3328
3329
3330
3331
3332 @Test
3333 void a108_isValidRegex() {
3334
3335 assertTrue(isValidRegex("[a-z]+"));
3336 assertTrue(isValidRegex("\\d+"));
3337 assertTrue(isValidRegex("^test$"));
3338 assertTrue(isValidRegex("(abc|def)"));
3339
3340
3341 assertFalse(isValidRegex("[a-z"));
3342 assertFalse(isValidRegex("(test"));
3343 assertFalse(isValidRegex("\\"));
3344 assertFalse(isValidRegex("*"));
3345
3346
3347 assertFalse(isValidRegex(null));
3348 assertFalse(isValidRegex(""));
3349 }
3350
3351
3352
3353
3354 @Test
3355 void a109_isValidTimeFormat() {
3356
3357 assertTrue(isValidTimeFormat("14:30:00", "HH:mm:ss"));
3358 assertTrue(isValidTimeFormat("02:30:00 PM", "hh:mm:ss a"));
3359 assertTrue(isValidTimeFormat("14:30", "HH:mm"));
3360 assertTrue(isValidTimeFormat("00:00:00", "HH:mm:ss"));
3361
3362
3363 assertFalse(isValidTimeFormat("25:00:00", "HH:mm:ss"));
3364 assertFalse(isValidTimeFormat("14:60:00", "HH:mm:ss"));
3365 assertFalse(isValidTimeFormat("14:30:60", "HH:mm:ss"));
3366 assertFalse(isValidTimeFormat("not-a-time", "HH:mm:ss"));
3367
3368
3369 assertFalse(isValidTimeFormat(null, "HH:mm:ss"));
3370 assertFalse(isValidTimeFormat("14:30:00", null));
3371 assertFalse(isValidTimeFormat("", "HH:mm:ss"));
3372 assertFalse(isValidTimeFormat("14:30:00", ""));
3373 }
3374
3375
3376
3377
3378 @Test
3379 void a110_isWhitespace() {
3380 assertFalse(isWhitespace(null));
3381 assertTrue(isWhitespace(""));
3382 assertTrue(isWhitespace(" "));
3383 assertTrue(isWhitespace("\t\n"));
3384 assertTrue(isWhitespace("\r\n\t "));
3385 assertFalse(isWhitespace(" a "));
3386 assertFalse(isWhitespace("hello"));
3387 }
3388
3389
3390
3391
3392 @Test
3393 void a111_join() {
3394
3395 assertNull(join((Collection<?>)null));
3396 assertEquals("1", join(l(a(1))));
3397 assertEquals("1,2", join(l(a(1, 2))));
3398
3399
3400 assertNull(join((Collection<?>)null, ','));
3401 assertEquals("1", join(l(a(1)), ','));
3402 assertEquals("1,2", join(l(a(1, 2)), ','));
3403
3404
3405 assertNull(join((Collection<?>)null, ","));
3406 assertEquals("1", join(l(a(1)), ","));
3407 assertEquals("1,2", join(l(a(1, 2)), ","));
3408
3409
3410 assertNull(join((int[])null, ','));
3411 assertEquals("1", join(ints(1), ','));
3412 assertEquals("1,2", join(ints(1, 2), ','));
3413
3414
3415 assertNull(join((Object[])null, ','));
3416 assertEquals("1", join(a(1), ','));
3417 assertEquals("1,2", join(a(1, 2), ','));
3418
3419
3420 assertNull(join((Object[])null, ","));
3421 assertEquals("1", join(a(1), ","));
3422 assertEquals("1,2", join(a(1, 2), ","));
3423
3424
3425 assertEquals("", join());
3426 assertEquals("a", join("a"));
3427 assertEquals("a,b", join("a", "b"));
3428
3429
3430 var collection = new ArrayList<>();
3431 collection.add("a");
3432 collection.add("b");
3433 collection.add("c");
3434 assertNull(join((Collection<?>)null, ','));
3435 assertEquals("", join(Collections.emptyList(), ','));
3436 assertEquals("a", join(Collections.singletonList("a"), ','));
3437 assertEquals("a,b,c", join(collection, ','));
3438
3439
3440 var sb1 = new StringBuilder("prefix-");
3441 assertSame(sb1, join((Collection<?>)null, ",", sb1));
3442 assertEquals("prefix-a,b,c", join(collection, ",", new StringBuilder("prefix-")).toString());
3443
3444
3445 var list = Arrays.asList("x", "y", "z");
3446 assertNull(join((List<?>)null, '|'));
3447 assertEquals("x|y|z", join(list, '|'));
3448
3449
3450 assertNull(join((List<?>)null, "|"));
3451 assertEquals("x|y|z", join(list, "|"));
3452
3453
3454 var sb2 = new StringBuilder("start-");
3455 assertSame(sb2, join((List<?>)null, "|", sb2));
3456 assertEquals("start-x|y|z", join(list, "|", new StringBuilder("start-")).toString());
3457
3458
3459 var arr = new Object[]{"1", "2", "3"};
3460 var sb3 = new StringBuilder("begin-");
3461 assertSame(sb3, join((Object[])null, '-', sb3));
3462 assertEquals("begin-1-2-3", join(arr, '-', new StringBuilder("begin-")).toString());
3463 }
3464
3465
3466
3467
3468 @Test
3469 void a112_joine() {
3470 assertNull(joine(null, ','));
3471 assertEquals("x\\,y,z", joine(l(a("x,y", "z")), ','));
3472 assertEquals("a,b", joine(l(a("a", "b")), ','));
3473 assertEquals("a\\|b", joine(l(a("a|b")), '|'));
3474 }
3475
3476
3477
3478
3479 @Test
3480 void a113_joinIntArrayString() {
3481
3482 assertEquals("", join((int[])null, ","));
3483
3484
3485 assertEquals("", join(new int[0], ","));
3486
3487
3488 assertEquals("1", join(new int[]{1}, ","));
3489 assertEquals("1", join(new int[]{1}, "-"));
3490
3491
3492 assertEquals("1,2,3", join(new int[]{1, 2, 3}, ","));
3493 assertEquals("1-2-3", join(new int[]{1, 2, 3}, "-"));
3494 assertEquals("1 2 3", join(new int[]{1, 2, 3}, " "));
3495
3496
3497 assertEquals("123", join(new int[]{1, 2, 3}, null));
3498
3499
3500 assertEquals("123", join(new int[]{1, 2, 3}, ""));
3501
3502
3503 assertEquals("100,200,300", join(new int[]{100, 200, 300}, ","));
3504 assertEquals("-1,0,1", join(new int[]{-1, 0, 1}, ","));
3505 }
3506
3507
3508
3509
3510 @Test
3511 void a114_joinnl() {
3512 assertNull(joinnl(null));
3513 assertEquals("", joinnl(new Object[0]));
3514 assertEquals("a", joinnl(a("a")));
3515 assertEquals("a\nb", joinnl(a("a", "b")));
3516 assertEquals("1\n2\n3", joinnl(a(1, 2, 3)));
3517 }
3518
3519
3520
3521
3522 @Test
3523 void a115_kebabCase() {
3524 assertNull(kebabCase(null));
3525 assertEquals("", kebabCase(""));
3526 assertEquals("hello-world", kebabCase("hello world"));
3527 assertEquals("hello-world", kebabCase("helloWorld"));
3528 assertEquals("hello-world", kebabCase("HelloWorld"));
3529 assertEquals("hello-world", kebabCase("hello_world"));
3530 assertEquals("hello-world", kebabCase("hello-world"));
3531 assertEquals("xml-http-request", kebabCase("XMLHttpRequest"));
3532 assertEquals("hello-world-test", kebabCase("Hello_World-Test"));
3533 assertEquals("test", kebabCase("test"));
3534 assertEquals("test", kebabCase("TEST"));
3535 assertEquals("hello-123-world", kebabCase("hello 123 world"));
3536
3537
3538
3539 assertEquals("", kebabCase(" "));
3540 assertEquals("", kebabCase("\t\t"));
3541 assertEquals("", kebabCase("___"));
3542 assertEquals("", kebabCase("---"));
3543 assertEquals("", kebabCase(" \t_-\t "));
3544 }
3545
3546
3547
3548
3549 @Test
3550 void a116_lastIndexOf() {
3551 assertEquals(12, lastIndexOf("hello world world", "world"));
3552 assertEquals(6, lastIndexOf("hello world", "world"));
3553 assertEquals(0, lastIndexOf("hello world", "hello"));
3554 assertEquals(-1, lastIndexOf("hello world", "xyz"));
3555 assertEquals(-1, lastIndexOf(null, "test"));
3556 assertEquals(-1, lastIndexOf("test", null));
3557 assertEquals(-1, lastIndexOf(null, null));
3558 assertEquals(4, lastIndexOf("ababab", "ab"));
3559 }
3560
3561
3562
3563
3564 @Test
3565 void a117_lastIndexOfIgnoreCase() {
3566 assertEquals(12, lastIndexOfIgnoreCase("Hello World World", "world"));
3567 assertEquals(12, lastIndexOfIgnoreCase("Hello World World", "WORLD"));
3568 assertEquals(6, lastIndexOfIgnoreCase("Hello World", "world"));
3569 assertEquals(6, lastIndexOfIgnoreCase("Hello World", "WORLD"));
3570 assertEquals(0, lastIndexOfIgnoreCase("Hello World", "hello"));
3571 assertEquals(-1, lastIndexOfIgnoreCase("Hello World", "xyz"));
3572 assertEquals(-1, lastIndexOfIgnoreCase(null, "test"));
3573 assertEquals(-1, lastIndexOfIgnoreCase("test", null));
3574 assertEquals(-1, lastIndexOfIgnoreCase(null, null));
3575 assertEquals(4, lastIndexOfIgnoreCase("AbAbAb", "ab"));
3576 }
3577
3578
3579
3580
3581 @Test
3582 void a118_lastNonWhitespaceChar() {
3583 assertEquals('r', lastNonWhitespaceChar("bar"));
3584 assertEquals('r', lastNonWhitespaceChar(" bar "));
3585 assertEquals('r', lastNonWhitespaceChar("\tbar\t"));
3586 assertEquals(0, lastNonWhitespaceChar(""));
3587 assertEquals(0, lastNonWhitespaceChar(" "));
3588 assertEquals(0, lastNonWhitespaceChar("\t"));
3589 assertEquals(0, lastNonWhitespaceChar(null));
3590 }
3591
3592
3593
3594
3595 @Test
3596 void a119_left() {
3597 assertNull(left(null, 3));
3598 assertEquals("", left("", 3));
3599 assertEquals("hel", left("hello", 3));
3600 assertEquals("hello", left("hello", 10));
3601 assertEquals("", left("hello", 0));
3602 assertEquals("", left("hello", -1));
3603 }
3604
3605
3606
3607
3608 @Test
3609 void a120_levenshteinDistance() {
3610 assertEquals(0, levenshteinDistance("hello", "hello"));
3611 assertEquals(3, levenshteinDistance("kitten", "sitting"));
3612 assertEquals(3, levenshteinDistance("abc", ""));
3613 assertEquals(3, levenshteinDistance("", "abc"));
3614 assertEquals(1, levenshteinDistance("hello", "hallo"));
3615 assertEquals(1, levenshteinDistance("hello", "helo"));
3616 assertEquals(1, levenshteinDistance("hello", "hell"));
3617 assertEquals(1, levenshteinDistance("hello", "hellox"));
3618
3619 assertEquals(0, levenshteinDistance(null, null));
3620 assertEquals(5, levenshteinDistance("hello", null));
3621 assertEquals(5, levenshteinDistance(null, "hello"));
3622 }
3623
3624
3625
3626
3627 @Test
3628 void a121_lineCount() {
3629
3630 assertEquals(3, lineCount("line1\nline2\nline3"));
3631 assertEquals(1, lineCount("single line"));
3632
3633
3634 assertEquals(2, lineCount("line1\r\nline2"));
3635
3636
3637 assertEquals(3, lineCount("line1\nline2\r\nline3"));
3638
3639
3640 assertEquals(3, lineCount("line1\n\nline3"));
3641 assertEquals(2, lineCount("\nline2"));
3642 assertEquals(2, lineCount("line1\n"));
3643
3644
3645 assertEquals(3, lineCount("\n\n"));
3646
3647
3648 assertEquals(0, lineCount(null));
3649 assertEquals(0, lineCount(""));
3650
3651
3652 assertEquals(2, lineCount("line1\rline2"));
3653 assertEquals(3, lineCount("line1\rline2\rline3"));
3654 assertEquals(2, lineCount("\rline2"));
3655 assertEquals(2, lineCount("line1\r"));
3656 }
3657
3658
3659
3660
3661 @Test
3662 void a122_lowerCase() {
3663 assertNull(lowerCase(null));
3664 assertEquals("", lowerCase(""));
3665 assertEquals("hello", lowerCase("Hello"));
3666 assertEquals("hello", lowerCase("HELLO"));
3667 assertEquals("hello world", lowerCase("Hello World"));
3668 assertEquals("123", lowerCase("123"));
3669 assertEquals("hello123", lowerCase("Hello123"));
3670 }
3671
3672
3673
3674
3675 @Test
3676 void a123_mapped() {
3677 assertNull(mapped(null, String::toUpperCase));
3678 assertList(mapped(a(), String::toUpperCase));
3679 assertList(mapped(a("foo", "bar", "baz"), String::toUpperCase), "FOO", "BAR", "BAZ");
3680 assertList(mapped(a("FOO", "BAR", "BAZ"), String::toLowerCase), "foo", "bar", "baz");
3681 assertList(mapped(a("foo", "bar", "baz"), s -> "prefix-" + s), "prefix-foo", "prefix-bar", "prefix-baz");
3682 assertList(mapped(a("hello", "world"), s -> s.substring(0, 1)), "h", "w");
3683 assertList(mapped(a("test"), null), "test");
3684 assertList(mapped(a("a", "b", "c"), s -> s + s), "aa", "bb", "cc");
3685 }
3686
3687
3688
3689
3690 @Test
3691 void a124_matches() {
3692 assertTrue(matches("12345", "\\d+"));
3693 assertTrue(matches("abc123", "^[a-z]+\\d+$"));
3694 assertTrue(matches("hello", "^hello$"));
3695 assertTrue(matches("test@example.com", "^[a-z]+@[a-z]+\\.[a-z]+$"));
3696 assertFalse(matches("abc", "\\d+"));
3697 assertFalse(matches("123", "^[a-z]+$"));
3698 assertFalse(matches(null, "\\d+"));
3699 assertFalse(matches("test", null));
3700 assertFalse(matches(null, null));
3701
3702 assertThrows(java.util.regex.PatternSyntaxException.class, () -> matches("test", "["));
3703 }
3704
3705
3706
3707
3708 @Test
3709 void a125_metaphone() {
3710
3711 var code1 = metaphone("Smith");
3712 assertNotNull(code1);
3713 assertTrue(code1.startsWith("SM"));
3714
3715 var code2 = metaphone("Smythe");
3716 assertNotNull(code2);
3717 assertTrue(code2.startsWith("SM"));
3718
3719
3720 var code3 = metaphone("Robert");
3721 assertNotNull(code3);
3722
3723
3724 assertNull(metaphone(null));
3725 assertNull(metaphone(""));
3726 assertEquals("", metaphone("123"));
3727
3728
3729 var code4 = metaphone("A");
3730 assertNotNull(code4);
3731 assertFalse(code4.isEmpty());
3732
3733
3734
3735 assertNotNull(metaphone("KNIGHT"));
3736 assertNotNull(metaphone("GNOME"));
3737 assertNotNull(metaphone("PNUT"));
3738 assertNotNull(metaphone("AEROPLANE"));
3739 assertNotNull(metaphone("WRITE"));
3740
3741
3742 var codeX = metaphone("XRAY");
3743 assertNotNull(codeX);
3744 assertTrue(codeX.startsWith("S"));
3745
3746
3747 var codeWH = metaphone("WHITE");
3748 assertNotNull(codeWH);
3749 assertTrue(codeWH.startsWith("W"));
3750
3751
3752 var codeDD = metaphone("ADD");
3753 assertNotNull(codeDD);
3754
3755
3756 var codeLL = metaphone("HELLO");
3757 assertNotNull(codeLL);
3758
3759
3760
3761 var codeCC = metaphone("ACCENT");
3762 assertNotNull(codeCC);
3763
3764
3765
3766 var codeCH = metaphone("CHURCH");
3767 assertNotNull(codeCH);
3768 assertTrue(codeCH.contains("X"));
3769
3770
3771 var codeSCH = metaphone("SCHOOL");
3772 assertNotNull(codeSCH);
3773
3774
3775 var codeCI = metaphone("CITY");
3776 assertNotNull(codeCI);
3777 assertTrue(codeCI.contains("S"));
3778
3779 var codeCE = metaphone("CENT");
3780 assertNotNull(codeCE);
3781 assertTrue(codeCE.contains("S"));
3782
3783 var codeCY = metaphone("CYCLE");
3784 assertNotNull(codeCY);
3785 assertTrue(codeCY.contains("S"));
3786
3787
3788 var codeCA = metaphone("CAT");
3789 assertNotNull(codeCA);
3790 assertTrue(codeCA.contains("K"));
3791
3792
3793
3794 var codeDGE = metaphone("EDGE");
3795 assertNotNull(codeDGE);
3796 assertTrue(codeDGE.contains("J"));
3797
3798 var codeDGI = metaphone("BUDGIE");
3799 assertNotNull(codeDGI);
3800
3801 var codeDGY = metaphone("BUDGY");
3802 assertNotNull(codeDGY);
3803
3804
3805
3806 var codeGH = metaphone("NIGHT");
3807 assertNotNull(codeGH);
3808
3809
3810 var codeGN = metaphone("SIGN");
3811 assertNotNull(codeGN);
3812
3813
3814 var codeGE = metaphone("AGE");
3815 assertNotNull(codeGE);
3816 assertTrue(codeGE.contains("J"));
3817
3818 var codeGI = metaphone("GIRAFFE");
3819 assertNotNull(codeGI);
3820
3821
3822 var codeGA = metaphone("GATE");
3823 assertNotNull(codeGA);
3824 assertTrue(codeGA.contains("K"));
3825
3826
3827
3828 var codeH = metaphone("AHOY");
3829 assertNotNull(codeH);
3830
3831
3832 var codeH2 = metaphone("HELLO");
3833 assertNotNull(codeH2);
3834
3835
3836
3837 var codeCK = metaphone("BACK");
3838 assertNotNull(codeCK);
3839
3840
3841 var codeK = metaphone("KITE");
3842 assertNotNull(codeK);
3843 assertTrue(codeK.contains("K"));
3844
3845
3846
3847 var codePH = metaphone("PHONE");
3848 assertNotNull(codePH);
3849 assertTrue(codePH.contains("F"));
3850
3851
3852 var codeP = metaphone("PARK");
3853 assertNotNull(codeP);
3854 assertTrue(codeP.contains("P"));
3855
3856
3857 var codeQ = metaphone("QUICK");
3858 assertNotNull(codeQ);
3859 assertTrue(codeQ.contains("K"));
3860
3861
3862
3863 var codeSH = metaphone("SHIP");
3864 assertNotNull(codeSH);
3865 assertTrue(codeSH.contains("X"));
3866
3867
3868 var codeSIO = metaphone("VISION");
3869 assertNotNull(codeSIO);
3870
3871 var codeSIA = metaphone("ASIA");
3872 assertNotNull(codeSIA);
3873
3874
3875 var codeS = metaphone("SUN");
3876 assertNotNull(codeS);
3877 assertTrue(codeS.contains("S"));
3878
3879
3880
3881 var codeTH = metaphone("THINK");
3882 assertNotNull(codeTH);
3883 assertTrue(codeTH.contains("0"));
3884
3885
3886 var codeTIO = metaphone("NATION");
3887 assertNotNull(codeTIO);
3888
3889 var codeTIA = metaphone("RATIO");
3890 assertNotNull(codeTIA);
3891
3892
3893 var codeT = metaphone("TANK");
3894 assertNotNull(codeT);
3895 assertTrue(codeT.contains("T"));
3896
3897
3898 var codeV = metaphone("VASE");
3899 assertNotNull(codeV);
3900 assertTrue(codeV.contains("F"));
3901
3902
3903
3904 var codeW = metaphone("WATER");
3905 assertNotNull(codeW);
3906 assertTrue(codeW.contains("W"));
3907
3908 var codeY = metaphone("YELLOW");
3909 assertNotNull(codeY);
3910 assertTrue(codeY.contains("Y"));
3911
3912
3913 var codeW2 = metaphone("SWIM");
3914 assertNotNull(codeW2);
3915
3916
3917
3918 var codeX2 = metaphone("XYLOPHONE");
3919 assertNotNull(codeX2);
3920 assertTrue(codeX2.startsWith("S"));
3921
3922
3923 var codeX3 = metaphone("AXE");
3924 assertNotNull(codeX3);
3925 assertTrue(codeX3.contains("KS"));
3926
3927
3928 var codeZ = metaphone("ZOO");
3929 assertNotNull(codeZ);
3930 assertTrue(codeZ.contains("S"));
3931
3932
3933
3934 var codeMB = metaphone("LAMB");
3935 assertNotNull(codeMB);
3936
3937
3938
3939 var codeMB2 = metaphone("LAMBS");
3940 assertNotNull(codeMB2);
3941
3942
3943 var codeB = metaphone("BAT");
3944 assertNotNull(codeB);
3945 assertTrue(codeB.contains("B"));
3946
3947
3948
3949 var codeD = metaphone("DOG");
3950 assertNotNull(codeD);
3951 assertTrue(codeD.contains("T"));
3952
3953 var codeDGA = metaphone("BUDGA");
3954 assertNotNull(codeDGA);
3955 assertTrue(codeDGA.contains("T"));
3956
3957
3958
3959 var codeGH2 = metaphone("AUGHT");
3960 assertNotNull(codeGH2);
3961 assertTrue(codeGH2.contains("K"));
3962
3963
3964 var codeGN2 = metaphone("SIGNAL");
3965 assertNotNull(codeGN2);
3966 assertTrue(codeGN2.contains("K"));
3967
3968
3969 var codeGGE = metaphone("AGGIE");
3970 assertNotNull(codeGGE);
3971
3972
3973
3974 var codeGHA = metaphone("GHAST");
3975 assertNotNull(codeGHA);
3976 var codeGHE = metaphone("GHETTO");
3977 assertNotNull(codeGHE);
3978 var codeGHI = metaphone("GHILLIE");
3979 assertNotNull(codeGHI);
3980 var codeGHO = metaphone("GHOST");
3981 assertNotNull(codeGHO);
3982 var codeGHU = metaphone("GHOUL");
3983 assertNotNull(codeGHU);
3984
3985
3986 var codeGNE = metaphone("SIGNE");
3987 assertNotNull(codeGNE);
3988 var codeGND = metaphone("SIGND");
3989 assertNotNull(codeGND);
3990
3991
3992
3993 var codeGY = metaphone("GYM");
3994 assertNotNull(codeGY);
3995 assertTrue(codeGY.contains("J"));
3996 var codeGY2 = metaphone("AGY");
3997 assertNotNull(codeGY2);
3998 assertTrue(codeGY2.contains("J"));
3999
4000
4001
4002 var codeH3 = metaphone("AHOY");
4003 assertNotNull(codeH3);
4004
4005
4006
4007 var codeH4 = metaphone("HELLO");
4008 assertNotNull(codeH4);
4009 assertTrue(codeH4.contains("H"));
4010
4011
4012
4013 var codeTI = metaphone("TICK");
4014 assertNotNull(codeTI);
4015 assertTrue(codeTI.contains("T"));
4016
4017
4018
4019
4020
4021
4022 }
4023
4024
4025
4026
4027 @Test
4028 void a126_mid() {
4029 assertNull(mid(null, 1, 3));
4030 assertEquals("", mid("", 1, 3));
4031 assertEquals("ell", mid("hello", 1, 3));
4032 assertEquals("ello", mid("hello", 1, 10));
4033 assertEquals("", mid("hello", 10, 3));
4034 assertEquals("", mid("hello", -1, 3));
4035 assertEquals("", mid("hello", 1, -1));
4036 }
4037
4038
4039
4040
4041 @Test
4042 void a127_mostFrequentChar() {
4043 assertEquals('l', mostFrequentChar("hello"));
4044 assertEquals('a', mostFrequentChar("aabbcc"));
4045 assertEquals('a', mostFrequentChar("abcabc"));
4046 assertEquals('t', mostFrequentChar("test"));
4047 assertEquals('l', mostFrequentChar("hello world"));
4048 assertEquals('\0', mostFrequentChar(null));
4049 assertEquals('\0', mostFrequentChar(""));
4050 }
4051
4052
4053
4054
4055 @Test
4056 void a128_naturalCompare() {
4057
4058 assertTrue(naturalCompare("file2.txt", "file10.txt") < 0);
4059 assertTrue(naturalCompare("file10.txt", "file2.txt") > 0);
4060 assertEquals(0, naturalCompare("file1.txt", "file1.txt"));
4061 assertTrue(naturalCompare("a2", "a10") < 0);
4062 assertTrue(naturalCompare("a10", "a2") > 0);
4063
4064
4065 assertTrue(naturalCompare("apple", "banana") < 0);
4066 assertTrue(naturalCompare("banana", "apple") > 0);
4067 assertEquals(0, naturalCompare("test", "test"));
4068
4069
4070 assertTrue(naturalCompare(null, "test") < 0);
4071 assertTrue(naturalCompare("test", null) > 0);
4072 assertEquals(0, naturalCompare(null, null));
4073
4074
4075 assertTrue(naturalCompare("file002.txt", "file10.txt") < 0);
4076 assertTrue(naturalCompare("file010.txt", "file002.txt") > 0);
4077
4078 assertTrue(naturalCompare("file0002.txt", "file0010.txt") < 0);
4079 assertTrue(naturalCompare("file0010.txt", "file0002.txt") > 0);
4080
4081
4082 assertTrue(naturalCompare("file2.txt", "file10.txt") < 0);
4083 assertTrue(naturalCompare("file100.txt", "file9.txt") > 0);
4084
4085
4086 assertTrue(naturalCompare("file12.txt", "file13.txt") < 0);
4087 assertTrue(naturalCompare("file13.txt", "file12.txt") > 0);
4088 assertEquals(0, naturalCompare("file12.txt", "file12.txt"));
4089 assertTrue(naturalCompare("file19.txt", "file20.txt") < 0);
4090
4091
4092
4093 assertTrue(naturalCompare("file12abc", "file12def") < 0);
4094 assertTrue(naturalCompare("file12def", "file12abc") > 0);
4095 assertEquals(0, naturalCompare("file12abc", "file12abc"));
4096
4097
4098 assertTrue(naturalCompare("file1", "file10.txt") < 0);
4099 assertTrue(naturalCompare("file10.txt", "file1") > 0);
4100 assertTrue(naturalCompare("abc", "abcd") < 0);
4101 assertTrue(naturalCompare("abcd", "abc") > 0);
4102 }
4103
4104
4105
4106
4107 @Test
4108 void a129_normalizeUnicode() {
4109
4110 var normalized = normalizeUnicode("café");
4111 assertNotNull(normalized);
4112 assertNotEquals("café", normalized);
4113
4114
4115 assertNull(normalizeUnicode(null));
4116 assertEquals("", normalizeUnicode(""));
4117
4118
4119 assertEquals("hello", normalizeUnicode("hello"));
4120 }
4121
4122
4123
4124
4125 @Test
4126 void a130_normalizeWhitespace() {
4127 assertNull(normalizeWhitespace(null));
4128 assertEquals("", normalizeWhitespace(""));
4129 assertEquals("hello world", normalizeWhitespace("hello \t\n world"));
4130 assertEquals("hello world", normalizeWhitespace(" hello world "));
4131 assertEquals("a b c", normalizeWhitespace("a b c"));
4132 }
4133
4134
4135
4136
4137 @Test
4138 void a131_notContains() {
4139
4140 assertFalse(notContains("test", 't'));
4141 assertTrue(notContains("test", 'x'));
4142 assertTrue(notContains(null, 't'));
4143
4144
4145 assertFalse(notContains("test", "te"));
4146 assertTrue(notContains("test", "xx"));
4147 assertTrue(notContains(null, "test"));
4148
4149
4150 assertFalse(notContains("test", "te"));
4151 assertTrue(notContains("test", "xyz"));
4152 assertTrue(notContains(null, "test"));
4153 }
4154
4155
4156
4157
4158 @Test
4159 void a132_notContainsAll() {
4160
4161 assertFalse(notContainsAll("test", 't', 'e'));
4162 assertTrue(notContainsAll("test", 'x', 'y'));
4163 assertTrue(notContainsAll(null, 't', 'e'));
4164
4165
4166 assertFalse(notContainsAll("test", "te", "es"));
4167 assertTrue(notContainsAll("test", "xy", "zz"));
4168 assertTrue(notContainsAll(null, "te", "es"));
4169
4170
4171 assertFalse(notContainsAll("test", "te", "es"));
4172 assertTrue(notContainsAll("test", "xy", "zz"));
4173 assertTrue(notContainsAll(null, "te", "es"));
4174 }
4175
4176
4177
4178
4179 @Test
4180 void a133_notContainsAllCharSequence() {
4181
4182 assertFalse(notContainsAll("test", (CharSequence)"te", (CharSequence)"st"));
4183 assertFalse(notContainsAll("hello world", (CharSequence)"hello", (CharSequence)"world"));
4184
4185
4186 assertTrue(notContainsAll("test", (CharSequence)"te", (CharSequence)"xx"));
4187 assertTrue(notContainsAll("test", (CharSequence)"xy", (CharSequence)"zz"));
4188
4189
4190 assertTrue(notContainsAll(null, (CharSequence)"te", (CharSequence)"st"));
4191
4192
4193 assertFalse(notContainsAll("test", new StringBuilder("te"), new StringBuilder("st")));
4194 assertTrue(notContainsAll("test", new StringBuilder("te"), new StringBuilder("xx")));
4195 }
4196
4197
4198
4199
4200 @Test
4201 void a134_notContainsAny() {
4202
4203 assertFalse(notContainsAny("test", 't', 'x'));
4204 assertTrue(notContainsAny("test", 'x', 'y'));
4205 assertTrue(notContainsAny(null, 't', 'x'));
4206
4207
4208 assertFalse(notContainsAny("test", "te", "xx"));
4209 assertTrue(notContainsAny("test", "xy", "zz"));
4210 assertTrue(notContainsAny(null, "te", "xx"));
4211
4212
4213 assertFalse(notContainsAny("test", "te", "xx"));
4214 assertTrue(notContainsAny("test", "xy", "zz"));
4215 assertTrue(notContainsAny(null, "te", "xx"));
4216 }
4217
4218
4219
4220
4221 @Test
4222 void a135_notContainsAnyCharSequence() {
4223
4224 assertFalse(notContainsAny("test", (CharSequence)"te", (CharSequence)"xx"));
4225 assertFalse(notContainsAny("test", (CharSequence)"xx", (CharSequence)"st"));
4226
4227
4228 assertTrue(notContainsAny("test", (CharSequence)"xy", (CharSequence)"zz"));
4229 assertTrue(notContainsAny("test", (CharSequence)"aa", (CharSequence)"bb"));
4230
4231
4232 assertTrue(notContainsAny(null, (CharSequence)"te", (CharSequence)"xx"));
4233
4234
4235 assertFalse(notContainsAny("test", new StringBuilder("te"), new StringBuilder("xx")));
4236 assertTrue(notContainsAny("test", new StringBuilder("xy"), new StringBuilder("zz")));
4237 }
4238
4239
4240
4241
4242 @Test
4243 void a136_notContainsCharSequence() {
4244
4245 assertFalse(notContains("test", (CharSequence)"te"));
4246 assertFalse(notContains("test", (CharSequence)"st"));
4247 assertTrue(notContains("test", (CharSequence)"xx"));
4248 assertTrue(notContains(null, (CharSequence)"test"));
4249
4250
4251 assertFalse(notContains("test", new StringBuilder("te")));
4252 assertTrue(notContains("test", new StringBuilder("xx")));
4253 assertTrue(notContains(null, new StringBuilder("test")));
4254
4255
4256 assertFalse(notContains("test", new StringBuffer("te")));
4257 assertTrue(notContains("test", new StringBuffer("xx")));
4258 }
4259
4260
4261
4262
4263 @Test
4264 void a138_obfuscate() {
4265 assertEquals("*", obfuscate(null));
4266 assertEquals("*", obfuscate(""));
4267 assertEquals("*", obfuscate("a"));
4268 assertEquals("p*", obfuscate("pa"));
4269 assertEquals("p*******", obfuscate("password"));
4270 assertEquals("1*****", obfuscate("123456"));
4271 }
4272
4273
4274
4275
4276 @Test
4277 void a140_ordinal() {
4278 assertEquals("1st", ordinal(1));
4279 assertEquals("2nd", ordinal(2));
4280 assertEquals("3rd", ordinal(3));
4281 assertEquals("4th", ordinal(4));
4282 assertEquals("11th", ordinal(11));
4283 assertEquals("12th", ordinal(12));
4284 assertEquals("13th", ordinal(13));
4285 assertEquals("21st", ordinal(21));
4286 assertEquals("22nd", ordinal(22));
4287 assertEquals("23rd", ordinal(23));
4288 assertEquals("24th", ordinal(24));
4289 assertEquals("101st", ordinal(101));
4290 assertEquals("102nd", ordinal(102));
4291 assertEquals("103rd", ordinal(103));
4292 assertEquals("111th", ordinal(111));
4293 assertEquals("-1st", ordinal(-1));
4294 }
4295
4296
4297
4298
4299 @Test
4300 void a141_padCenter() {
4301 assertEquals(" ", padCenter(null, 5, ' '));
4302 assertEquals(" ", padCenter("", 5, ' '));
4303 assertEquals(" hi ", padCenter("hi", 6, ' '));
4304 assertEquals(" hi ", padCenter("hi", 7, ' '));
4305 assertEquals("hello", padCenter("hello", 3, ' '));
4306 assertEquals(" hello ", padCenter("hello", 7, ' '));
4307 }
4308
4309
4310
4311
4312 @Test
4313 void a142_padLeft() {
4314 assertEquals(" ", padLeft(null, 5, ' '));
4315 assertEquals(" ", padLeft("", 5, ' '));
4316 assertEquals(" hello", padLeft("hello", 8, ' '));
4317 assertEquals("hello", padLeft("hello", 3, ' '));
4318 assertEquals("00123", padLeft("123", 5, '0'));
4319 }
4320
4321
4322
4323
4324 @Test
4325 void a143_padRight() {
4326 assertEquals(" ", padRight(null, 5, ' '));
4327 assertEquals(" ", padRight("", 5, ' '));
4328 assertEquals("hello ", padRight("hello", 8, ' '));
4329 assertEquals("hello", padRight("hello", 3, ' '));
4330 assertEquals("12300", padRight("123", 5, '0'));
4331 }
4332
4333
4334
4335
4336 @Test
4337 void a144_parseCharacter() {
4338 assertNull(parseCharacter(null));
4339 assertNull(parseCharacter(""));
4340 assertEquals(Character.valueOf('a'), parseCharacter("a"));
4341 assertEquals(Character.valueOf('1'), parseCharacter("1"));
4342 assertEquals(Character.valueOf(' '), parseCharacter(" "));
4343
4344 assertThrows(IllegalArgumentException.class, () -> parseCharacter("ab"));
4345 assertThrows(IllegalArgumentException.class, () -> parseCharacter("hello"));
4346 }
4347
4348
4349
4350
4351 @Test
4352 void a145_parseFloat() {
4353 assertEquals(1.5f, parseFloat("1.5"), 0.0001f);
4354 assertEquals(1000.5f, parseFloat("1_000.5"), 0.0001f);
4355 assertEquals(-123.45f, parseFloat("-123.45"), 0.0001f);
4356 assertEquals(0.0f, parseFloat("0"), 0.0001f);
4357
4358 assertThrows(NumberFormatException.class, () -> parseFloat("invalid"));
4359 assertThrows(IllegalArgumentException.class, () -> parseFloat(null));
4360 }
4361
4362
4363
4364
4365 @Test
4366 void a146_parseInt() {
4367 assertEquals(123, parseInt("123"));
4368 assertEquals(1000000, parseInt("1_000_000"));
4369 assertEquals(-456, parseInt("-456"));
4370 assertEquals(0, parseInt("0"));
4371
4372 assertThrows(NumberFormatException.class, () -> parseInt("invalid"));
4373 assertThrows(IllegalArgumentException.class, () -> parseInt(null));
4374 }
4375
4376
4377
4378
4379 @Test
4380 void a147_parseIntWithSuffix() {
4381
4382 assertEquals(1024, parseIntWithSuffix("1K"));
4383 assertEquals(1024 * 1024, parseIntWithSuffix("1M"));
4384 assertEquals(1024 * 1024 * 1024, parseIntWithSuffix("1G"));
4385
4386
4387 assertEquals(1000, parseIntWithSuffix("1k"));
4388 assertEquals(1000 * 1000, parseIntWithSuffix("1m"));
4389 assertEquals(1000 * 1000 * 1000, parseIntWithSuffix("1g"));
4390
4391
4392 assertEquals(123, parseIntWithSuffix("123"));
4393 assertEquals(456, parseIntWithSuffix("456"));
4394
4395
4396 assertEquals(1024, parseIntWithSuffix("1 K"));
4397 assertEquals(1000, parseIntWithSuffix("1 k"));
4398
4399
4400 assertThrows(IllegalArgumentException.class, () -> parseIntWithSuffix(null));
4401 }
4402
4403
4404
4405
4406
4407 @Test
4408 void a150_parseLong() {
4409 assertEquals(123L, parseLong("123"));
4410 assertEquals(1000000L, parseLong("1_000_000"));
4411 assertEquals(-456L, parseLong("-456"));
4412 assertEquals(0L, parseLong("0"));
4413
4414 assertThrows(NumberFormatException.class, () -> parseLong("invalid"));
4415 assertThrows(IllegalArgumentException.class, () -> parseLong(null));
4416 }
4417
4418
4419
4420
4421 @Test
4422 void a151_parseLongWithSuffix() {
4423
4424 assertEquals(1024L, parseLongWithSuffix("1K"));
4425 assertEquals(1024L * 1024, parseLongWithSuffix("1M"));
4426 assertEquals(1024L * 1024 * 1024, parseLongWithSuffix("1G"));
4427 assertEquals(1024L * 1024 * 1024 * 1024, parseLongWithSuffix("1T"));
4428
4429
4430 assertEquals(1125899906842624L, parseLongWithSuffix("1P"));
4431 assertEquals(2251799813685248L, parseLongWithSuffix("2P"));
4432
4433
4434 assertThrows(NumberFormatException.class, () -> parseLongWithSuffix("8192P"));
4435
4436
4437 assertEquals(1000L, parseLongWithSuffix("1k"));
4438 assertEquals(1000L * 1000, parseLongWithSuffix("1m"));
4439 assertEquals(1000L * 1000 * 1000, parseLongWithSuffix("1g"));
4440 assertEquals(1000L * 1000 * 1000 * 1000, parseLongWithSuffix("1t"));
4441
4442
4443 assertEquals(1000000000000000L, parseLongWithSuffix("1p"));
4444 assertEquals(2000000000000000L, parseLongWithSuffix("2p"));
4445
4446
4447 assertThrows(NumberFormatException.class, () -> parseLongWithSuffix("9224p"));
4448
4449
4450 assertEquals(123L, parseLongWithSuffix("123"));
4451 assertEquals(456L, parseLongWithSuffix("456"));
4452
4453
4454 assertThrows(IllegalArgumentException.class, () -> parseLongWithSuffix(null));
4455 }
4456
4457
4458
4459
4460 @Test
4461 void a152_parseMap() {
4462
4463 var map1 = parseMap("key1=value1,key2=value2", '=', ',', false);
4464 assertEquals(2, map1.size());
4465 assertEquals("value1", map1.get("key1"));
4466 assertEquals("value2", map1.get("key2"));
4467
4468
4469 var map2 = parseMap(" key1 = value1 ; key2 = value2 ", '=', ';', true);
4470 assertEquals(2, map2.size());
4471 assertEquals("value1", map2.get("key1"));
4472 assertEquals("value2", map2.get("key2"));
4473
4474
4475 var map3 = parseMap("a:1|b:2|c:3", ':', '|', false);
4476 assertEquals(3, map3.size());
4477 assertEquals("1", map3.get("a"));
4478 assertEquals("2", map3.get("b"));
4479 assertEquals("3", map3.get("c"));
4480
4481
4482 var map4 = parseMap("key1=,key2=value2", '=', ',', false);
4483 assertEquals(2, map4.size());
4484 assertEquals("", map4.get("key1"));
4485 assertEquals("value2", map4.get("key2"));
4486
4487
4488 assertTrue(parseMap(null, '=', ',', false).isEmpty());
4489 assertTrue(parseMap("", '=', ',', false).isEmpty());
4490
4491
4492 var map5 = parseMap("key1=value1,,key2=value2", '=', ',', false);
4493 assertEquals(2, map5.size());
4494 assertEquals("value1", map5.get("key1"));
4495 assertEquals("value2", map5.get("key2"));
4496
4497
4498 var map6 = parseMap("key1=value1,keyonly,key2=value2", '=', ',', false);
4499 assertEquals(3, map6.size());
4500 assertEquals("value1", map6.get("key1"));
4501 assertEquals("", map6.get("keyonly"));
4502 assertEquals("value2", map6.get("key2"));
4503
4504
4505 var map7 = parseMap(" key1 = value1 , keyonly , key2 = value2 ", '=', ',', true);
4506 assertEquals(3, map7.size());
4507 assertEquals("value1", map7.get("key1"));
4508 assertEquals("", map7.get("keyonly"));
4509 assertEquals("value2", map7.get("key2"));
4510 }
4511
4512
4513
4514
4515 @Test
4516 void a153_parseNumber() {
4517
4518 assertEquals(123, parseNumber("123", null));
4519 assertEquals(123, parseNumber("123", Integer.class));
4520 assertEquals((short)123, parseNumber("123", Short.class));
4521 assertEquals((long)123, parseNumber("123", Long.class));
4522
4523
4524 assertEquals(0x123, parseNumber("0x123", null));
4525 assertEquals(-0x123, parseNumber("-0x123", null));
4526
4527
4528 assertEquals(0.123f, parseNumber("0.123", null));
4529 assertEquals(-0.123f, parseNumber("-0.123", null));
4530
4531
4532 assertEquals(1000000, parseNumber("1_000_000", null));
4533
4534
4535 assertNull(parseNumber(null, null));
4536
4537
4538 assertEquals(0, parseNumber("", null));
4539 assertEquals(0, parseNumber("", Integer.class));
4540
4541
4542 assertEquals(123.45, parseNumber("123.45", Double.class));
4543 assertEquals(123.45, parseNumber("123.45", Double.TYPE));
4544
4545
4546 assertEquals(123.45f, parseNumber("123.45", Float.class));
4547 assertEquals(123.45f, parseNumber("123.45", Float.TYPE));
4548
4549
4550 assertEquals(123L, parseNumber("123", Long.class));
4551 assertEquals(123L, parseNumber("123", Long.TYPE));
4552 assertEquals(123L, parseNumber("123", java.util.concurrent.atomic.AtomicLong.class).longValue());
4553
4554
4555 assertEquals(123, parseNumber("123", Integer.class));
4556 assertEquals(123, parseNumber("123", Integer.TYPE));
4557
4558
4559 assertEquals((short)123, parseNumber("123", Short.class));
4560 assertEquals((short)123, parseNumber("123", Short.TYPE));
4561
4562
4563 assertEquals((byte)123, parseNumber("123", Byte.class));
4564 assertEquals((byte)123, parseNumber("123", Byte.TYPE));
4565
4566
4567
4568 assertEquals(1024L, parseNumber("1K", Long.class));
4569 assertEquals(1024L * 1024L, parseNumber("1M", Long.class));
4570 assertEquals(1024L * 1024L * 1024L, parseNumber("1G", Long.class));
4571 assertEquals(1000L, parseNumber("1k", Long.class));
4572 assertEquals(1000L * 1000L, parseNumber("1m", Long.class));
4573 assertEquals(1000L * 1000L * 1000L, parseNumber("1g", Long.class));
4574 }
4575
4576
4577
4578
4579 @Test
4580 void a154_pascalCase() {
4581 assertNull(pascalCase(null));
4582 assertEquals("", pascalCase(""));
4583 assertEquals("HelloWorld", pascalCase("hello world"));
4584 assertEquals("HelloWorld", pascalCase("helloWorld"));
4585 assertEquals("HelloWorld", pascalCase("HelloWorld"));
4586 assertEquals("HelloWorld", pascalCase("hello_world"));
4587 assertEquals("HelloWorld", pascalCase("hello-world"));
4588 assertEquals("XmlHttpRequest", pascalCase("XMLHttpRequest"));
4589 assertEquals("HelloWorldTest", pascalCase("Hello_World-Test"));
4590 assertEquals("Test", pascalCase("test"));
4591 assertEquals("Test", pascalCase("TEST"));
4592 assertEquals("Hello123World", pascalCase("hello 123 world"));
4593
4594
4595
4596 assertEquals("", pascalCase(" "));
4597 assertEquals("", pascalCase("\t\t"));
4598 assertEquals("", pascalCase("___"));
4599 assertEquals("", pascalCase("---"));
4600 assertEquals("", pascalCase(" \t_-\t "));
4601 }
4602
4603
4604
4605
4606 @Test
4607 void a155_pluralize() {
4608
4609 assertEquals("cat", pluralize("cat", 1));
4610 assertEquals("box", pluralize("box", 1));
4611 assertEquals("city", pluralize("city", 1));
4612
4613
4614 assertEquals("cats", pluralize("cat", 2));
4615 assertEquals("dogs", pluralize("dog", 2));
4616 assertEquals("books", pluralize("book", 0));
4617
4618
4619 assertEquals("boxes", pluralize("box", 2));
4620 assertEquals("buses", pluralize("bus", 2));
4621 assertEquals("buzzes", pluralize("buzz", 2));
4622 assertEquals("churches", pluralize("church", 2));
4623 assertEquals("dishes", pluralize("dish", 2));
4624
4625
4626 assertEquals("cities", pluralize("city", 2));
4627 assertEquals("countries", pluralize("country", 2));
4628 assertEquals("flies", pluralize("fly", 2));
4629
4630 assertEquals("days", pluralize("day", 2));
4631 assertEquals("boys", pluralize("boy", 2));
4632
4633
4634 assertEquals("leaves", pluralize("leaf", 2));
4635 assertEquals("lives", pluralize("life", 2));
4636 assertEquals("knives", pluralize("knife", 2));
4637
4638
4639 assertNull(pluralize(null, 2));
4640 assertEquals("", pluralize("", 2));
4641
4642
4643 assertEquals("ys", pluralize("y", 2));
4644
4645
4646 assertEquals("days", pluralize("day", 2));
4647 assertEquals("boys", pluralize("boy", 2));
4648 assertEquals("keys", pluralize("key", 2));
4649 assertEquals("guys", pluralize("guy", 2));
4650 }
4651
4652
4653
4654
4655 @Test
4656 void a156_random() {
4657
4658 for (var i = 0; i < 10; i++) {
4659 var random = random(5);
4660 assertNotNull(random);
4661 assertEquals(5, random.length());
4662
4663 assertTrue(random.matches("[a-z0-9]+"));
4664 }
4665
4666
4667 assertEquals("", random(0));
4668 }
4669
4670
4671
4672
4673 @Test
4674 void a157_randomAlphabetic() {
4675
4676 for (var i = 0; i < 10; i++) {
4677 var random = randomAlphabetic(8);
4678 assertNotNull(random);
4679 assertEquals(8, random.length());
4680
4681 assertTrue(random.matches("[a-zA-Z]+"));
4682 }
4683
4684
4685 assertEquals("", randomAlphabetic(0));
4686
4687
4688 assertThrows(IllegalArgumentException.class, () -> randomAlphabetic(-1));
4689 }
4690
4691
4692
4693
4694 @Test
4695 void a158_randomAlphanumeric() {
4696
4697 for (var i = 0; i < 10; i++) {
4698 var random = randomAlphanumeric(8);
4699 assertNotNull(random);
4700 assertEquals(8, random.length());
4701
4702 assertTrue(random.matches("[a-zA-Z0-9]+"));
4703 }
4704
4705
4706 assertEquals("", randomAlphanumeric(0));
4707
4708
4709 assertThrows(IllegalArgumentException.class, () -> randomAlphanumeric(-1));
4710 }
4711
4712
4713
4714
4715 @Test
4716 void a159_randomAscii() {
4717
4718 for (var i = 0; i < 10; i++) {
4719 var random = randomAscii(8);
4720 assertNotNull(random);
4721 assertEquals(8, random.length());
4722
4723 for (var j = 0; j < random.length(); j++) {
4724 var c = random.charAt(j);
4725 assertTrue(c >= 32 && c <= 126, "Character should be printable ASCII: " + c);
4726 }
4727 }
4728
4729
4730 assertEquals("", randomAscii(0));
4731
4732
4733 assertThrows(IllegalArgumentException.class, () -> randomAscii(-1));
4734 }
4735
4736
4737
4738
4739 @Test
4740 void a160_randomNumeric() {
4741
4742 for (var i = 0; i < 10; i++) {
4743 var random = randomNumeric(8);
4744 assertNotNull(random);
4745 assertEquals(8, random.length());
4746
4747 assertTrue(random.matches("[0-9]+"));
4748 }
4749
4750
4751 assertEquals("", randomNumeric(0));
4752
4753
4754 assertThrows(IllegalArgumentException.class, () -> randomNumeric(-1));
4755 }
4756
4757
4758
4759
4760 @Test
4761 void a161_randomString() {
4762
4763 var s1 = randomString(10, "ABC");
4764 assertNotNull(s1);
4765 assertEquals(10, s1.length());
4766 for (var i = 0; i < s1.length(); i++) {
4767 var c = s1.charAt(i);
4768 assertTrue(c == 'A' || c == 'B' || c == 'C', "Character should be A, B, or C: " + c);
4769 }
4770
4771 var s2 = randomString(5, "0123456789");
4772 assertNotNull(s2);
4773 assertEquals(5, s2.length());
4774 for (var i = 0; i < s2.length(); i++) {
4775 assertTrue(Character.isDigit(s2.charAt(i)));
4776 }
4777
4778
4779 assertEquals("", randomString(0, "ABC"));
4780
4781
4782 assertThrows(IllegalArgumentException.class, () -> randomString(-1, "ABC"));
4783
4784
4785 assertThrows(IllegalArgumentException.class, () -> randomString(5, null));
4786 assertThrows(IllegalArgumentException.class, () -> randomString(5, ""));
4787 }
4788
4789
4790
4791
4792 @Test
4793 void a162_readabilityScore() {
4794
4795 var simple = readabilityScore("The cat sat.");
4796 assertTrue(simple > 0);
4797
4798
4799 var complex = readabilityScore("The sophisticated implementation demonstrates exceptional complexity.");
4800 assertTrue(complex >= 0);
4801 assertTrue(complex <= 100);
4802
4803
4804 assertEquals(0.0, readabilityScore(null), 0.0001);
4805 assertEquals(0.0, readabilityScore(""), 0.0001);
4806
4807
4808
4809 assertEquals(0.0, readabilityScore("!!!"), 0.0001);
4810 assertEquals(0.0, readabilityScore("..."), 0.0001);
4811 assertEquals(0.0, readabilityScore(" "), 0.0001);
4812
4813
4814
4815
4816
4817
4818 var scoreSingle = readabilityScore("a");
4819 assertTrue(scoreSingle >= 0);
4820
4821 var scoreMixed = readabilityScore("a b c d e");
4822 assertTrue(scoreMixed >= 0 && scoreMixed <= 100);
4823
4824
4825 var score1 = readabilityScore("First sentence. Second sentence!");
4826 assertTrue(score1 > 0);
4827 assertTrue(score1 <= 100);
4828
4829 var score2 = readabilityScore("What is this? It is a test.");
4830 assertTrue(score2 > 0);
4831 assertTrue(score2 <= 100);
4832
4833
4834 var score3 = readabilityScore("This is a test without sentence endings");
4835 assertTrue(score3 > 0);
4836 assertTrue(score3 <= 100);
4837
4838
4839 var score = readabilityScore("This is a test sentence.");
4840 assertTrue(score >= 0.0 && score <= 100.0);
4841 }
4842
4843
4844
4845
4846 @Test
4847 void a163_readable() {
4848 assertNull(readable(null));
4849 assertEquals("[a,b,c]", readable(l("a", "b", "c")));
4850 assertEquals("{foo=bar}", readable(m("foo", "bar")));
4851 assertEquals("[1,2,3]", readable(ints(1, 2, 3)));
4852 assertEquals("test", readable(opt("test")));
4853 assertNull(readable(opte()));
4854
4855
4856 var customIterable = new Iterable<String>() {
4857 @Override
4858 public Iterator<String> iterator() {
4859 return Arrays.asList("x", "y", "z").iterator();
4860 }
4861 };
4862 assertEquals("[x,y,z]", readable(customIterable));
4863
4864
4865 var iterator = Arrays.asList("a", "b").iterator();
4866 assertEquals("[a,b]", readable(iterator));
4867
4868
4869 var enumeration = Collections.enumeration(Arrays.asList("1", "2", "3"));
4870 assertEquals("[1,2,3]", readable(enumeration));
4871
4872
4873 var cal = new GregorianCalendar(2023, Calendar.DECEMBER, 25, 14, 30, 0);
4874 cal.setTimeZone(TimeZone.getTimeZone("UTC"));
4875 var calStr = readable(cal);
4876 assertNotNull(calStr);
4877 assertTrue(calStr.contains("2023"));
4878
4879
4880 var date = new Date(1703520000000L);
4881 var dateStr = readable(date);
4882 assertNotNull(dateStr);
4883 assertTrue(dateStr.contains("2023"));
4884
4885
4886 var inputStream = new ByteArrayInputStream("Hello".getBytes(UTF8));
4887 var isStr = readable(inputStream);
4888 assertNotNull(isStr);
4889
4890
4891
4892 var reader = new StringReader("Test content");
4893 var readerStr = readable(reader);
4894 assertNotNull(readerStr);
4895 assertEquals("Test content", readerStr);
4896
4897
4898 var file = new File("test.txt");
4899 assertDoesNotThrow(() -> readable(file));
4900
4901
4902
4903 var bytes = new byte[]{0x48, 0x65, 0x6C, 0x6C, 0x6F};
4904 var bytesStr = readable(bytes);
4905 assertNotNull(bytesStr);
4906 assertEquals("48656C6C6F", bytesStr);
4907
4908
4909 enum TestEnum { VALUE1, VALUE2 }
4910 var enumValue = TestEnum.VALUE1;
4911 assertEquals("VALUE1", readable(enumValue));
4912
4913
4914 var clazz = String.class;
4915 var classStr = readable(clazz);
4916 assertNotNull(classStr);
4917 assertTrue(classStr.contains("String"));
4918
4919
4920 try {
4921 var method = String.class.getMethod("length");
4922 var methodStr = readable(method);
4923 assertNotNull(methodStr);
4924 assertTrue(methodStr.contains("length"));
4925 assertTrue(methodStr.contains("()"));
4926 } catch (NoSuchMethodException e) {
4927 fail("Method not found");
4928 }
4929
4930
4931 try {
4932 var constructor = String.class.getConstructor(String.class);
4933 var constructorStr = readable(constructor);
4934 assertNotNull(constructorStr);
4935 assertTrue(constructorStr.contains("String"));
4936 assertTrue(constructorStr.contains("("));
4937 } catch (NoSuchMethodException e) {
4938 fail("Constructor not found");
4939 }
4940
4941
4942 try {
4943 var method = String.class.getMethod("substring", int.class, int.class);
4944 var methodStr = readable(method);
4945 assertNotNull(methodStr);
4946 assertTrue(methodStr.contains("substring"));
4947 assertTrue(methodStr.contains("int"));
4948 assertTrue(methodStr.contains(","));
4949 } catch (NoSuchMethodException e) {
4950 fail("Method not found");
4951 }
4952
4953
4954 var classInfo = org.apache.juneau.commons.reflect.ClassInfo.of(String.class);
4955 var classInfoStr = readable(classInfo);
4956 assertNotNull(classInfoStr);
4957 assertTrue(classInfoStr.contains("String"));
4958
4959
4960 var methodInfoOpt = classInfo.getPublicMethod(m -> m.hasName("length"));
4961 if (methodInfoOpt.isPresent()) {
4962 var methodInfo = methodInfoOpt.get();
4963 var methodInfoStr = readable(methodInfo);
4964 assertNotNull(methodInfoStr);
4965 assertTrue(methodInfoStr.contains("length"));
4966
4967
4968 var params = methodInfo.getParameters();
4969 if (!params.isEmpty()) {
4970 var paramInfo = params.get(0);
4971 var paramInfoStr = readable(paramInfo);
4972 assertNotNull(paramInfoStr);
4973 }
4974 }
4975
4976
4977 var constructors = classInfo.getPublicConstructors();
4978 if (!constructors.isEmpty()) {
4979 var constructorInfo = constructors.get(0);
4980 var constructorInfoStr = readable(constructorInfo);
4981 assertNotNull(constructorInfoStr);
4982 assertTrue(constructorInfoStr.contains("String"));
4983 }
4984
4985
4986 var fieldInfoOpt = classInfo.getPublicField(f -> f.hasName("CASE_INSENSITIVE_ORDER"));
4987 if (fieldInfoOpt.isPresent()) {
4988 var fieldInfo = fieldInfoOpt.get();
4989 var fieldInfoStr = readable(fieldInfo);
4990 assertNotNull(fieldInfoStr);
4991 assertTrue(fieldInfoStr.contains("CASE_INSENSITIVE_ORDER"));
4992 }
4993
4994
4995 try {
4996 var field = String.class.getField("CASE_INSENSITIVE_ORDER");
4997 var fieldStr = readable(field);
4998 assertNotNull(fieldStr);
4999 assertTrue(fieldStr.contains("CASE_INSENSITIVE_ORDER"));
5000 assertTrue(fieldStr.contains("String"));
5001 } catch (NoSuchFieldException e) {
5002
5003 }
5004
5005
5006 try {
5007 var method = String.class.getMethod("substring", int.class, int.class);
5008 var parameters = method.getParameters();
5009 if (parameters.length > 0) {
5010 var paramStr = readable(parameters[0]);
5011 assertNotNull(paramStr);
5012
5013
5014 assertTrue(paramStr.length() > 0);
5015 }
5016 } catch (NoSuchMethodException e) {
5017 fail("Method not found");
5018 }
5019 }
5020
5021
5022
5023
5024 @Test
5025 void a165_remove() {
5026 assertNull(remove(null, "x"));
5027 assertEquals("hello", remove("hello", null));
5028 assertEquals("hello", remove("hello", ""));
5029 assertEquals("hell wrld", remove("hello world", "o"));
5030 assertEquals("hello world", remove("hello world", "xyz"));
5031 assertEquals("", remove("xxx", "x"));
5032 }
5033
5034
5035
5036
5037 @Test
5038 void a165_removeAccents() {
5039
5040 assertEquals("cafe", removeAccents("café"));
5041 assertEquals("naive", removeAccents("naïve"));
5042 assertEquals("resume", removeAccents("résumé"));
5043
5044
5045 assertEquals("Cafe", removeAccents("Café"));
5046 assertEquals("Zoe", removeAccents("Zoë"));
5047
5048
5049 assertEquals("hello", removeAccents("hello"));
5050 assertEquals("HELLO", removeAccents("HELLO"));
5051
5052
5053 assertNull(removeAccents(null));
5054
5055
5056 assertEquals("", removeAccents(""));
5057
5058
5059 assertEquals("Cafe", removeAccents("Café"));
5060 assertEquals("Ecole", removeAccents("École"));
5061 }
5062
5063
5064
5065
5066 @Test
5067 void a166_removeAll() {
5068 assertNull(removeAll(null, "x"));
5069 assertEquals("hello world test", removeAll("hello world test"));
5070 assertEquals("hello world test", removeAll("hello world test", (String[])null));
5071 assertEquals(" world ", removeAll("hello world test", "hello", "test"));
5072 assertEquals("hello world test", removeAll("hello world test", "xyz"));
5073 assertEquals("", removeAll("xxx", "x"));
5074 assertEquals("hello", removeAll("hello", "x", "y", "z"));
5075 assertEquals("", removeAll("abc", "a", "b", "c"));
5076 assertEquals("hello", removeAll("hello", null, "x"));
5077
5078
5079 assertEquals("", removeAll("", "x", "y"));
5080 assertEquals("", removeAll("", new String[0]));
5081 }
5082
5083
5084
5085
5086 @Test
5087 void a167_removeControlChars() {
5088 assertNull(removeControlChars(null));
5089 assertEquals("", removeControlChars(""));
5090 assertEquals("hello world", removeControlChars("hello\u0000\u0001world"));
5091 assertEquals("hello\nworld", removeControlChars("hello\nworld"));
5092 assertEquals("test", removeControlChars("test"));
5093 }
5094
5095
5096
5097
5098 @Test
5099 void a168_removeEnd() {
5100 assertNull(removeEnd(null, "x"));
5101 assertEquals("hello", removeEnd("hello", null));
5102 assertEquals("hello", removeEnd("hello", ""));
5103 assertEquals("hello ", removeEnd("hello world", "world"));
5104 assertEquals("hello world", removeEnd("hello world", "xyz"));
5105 assertEquals("", removeEnd("hello", "hello"));
5106 }
5107
5108
5109
5110
5111 @Test
5112 void a169_removeNonPrintable() {
5113 assertNull(removeNonPrintable(null));
5114 assertEquals("", removeNonPrintable(""));
5115 assertEquals("helloworld", removeNonPrintable("hello\u0000world"));
5116 assertEquals("test", removeNonPrintable("test"));
5117 }
5118
5119
5120
5121
5122 @Test
5123 void a170_removeStart() {
5124 assertNull(removeStart(null, "x"));
5125 assertEquals("hello", removeStart("hello", null));
5126 assertEquals("hello", removeStart("hello", ""));
5127 assertEquals(" world", removeStart("hello world", "hello"));
5128 assertEquals("hello world", removeStart("hello world", "xyz"));
5129 assertEquals("", removeStart("hello", "hello"));
5130 }
5131
5132
5133
5134
5135 @Test
5136 void a171_removeUnderscores() {
5137 assertEquals("1000000", removeUnderscores("1_000_000"));
5138 assertEquals("1000.5", removeUnderscores("1_000.5"));
5139 assertEquals("helloworld", removeUnderscores("hello_world"));
5140 assertEquals("nounderscores", removeUnderscores("no_underscores"));
5141 assertEquals("Hello", removeUnderscores("Hello"));
5142
5143 assertThrows(IllegalArgumentException.class, () -> removeUnderscores(null));
5144 }
5145
5146
5147
5148
5149 @Test
5150 void a172_repeat() {
5151 assertEquals("", repeat(0, "abc"));
5152 assertEquals("abc", repeat(1, "abc"));
5153 assertEquals("abcabcabc", repeat(3, "abc"));
5154 assertEquals("---", repeat(3, "-"));
5155 assertEquals("", repeat(5, ""));
5156 }
5157
5158
5159
5160
5161 @Test
5162 void a173_replaceUnicodeSequences() {
5163 assertEquals("Hello", replaceUnicodeSequences("\\u0048\\u0065\\u006c\\u006c\\u006f"));
5164 assertEquals("A", replaceUnicodeSequences("\\u0041"));
5165 assertEquals("test", replaceUnicodeSequences("test"));
5166 assertEquals("Hello World", replaceUnicodeSequences("\\u0048ello \\u0057orld"));
5167
5168 assertEquals("Hello\\u", replaceUnicodeSequences("\\u0048ello\\u"));
5169 }
5170
5171
5172
5173
5174 @Test
5175 void a174_reverse() {
5176 assertNull(StringUtils.reverse(null));
5177 assertEquals("", reverse(""));
5178 assertEquals("olleh", reverse("hello"));
5179 assertEquals("321", reverse("123"));
5180 assertEquals("cba", reverse("abc"));
5181 }
5182
5183
5184
5185
5186 @Test
5187 void a175_right() {
5188 assertNull(right(null, 3));
5189 assertEquals("", right("", 3));
5190 assertEquals("llo", right("hello", 3));
5191 assertEquals("hello", right("hello", 10));
5192 assertEquals("", right("hello", 0));
5193 assertEquals("", right("hello", -1));
5194 }
5195
5196
5197
5198
5199 @Test
5200 void a176_sanitize() {
5201 assertNull(sanitize(null));
5202 assertEquals("", sanitize(""));
5203 assertEquals("Hello World", sanitize("Hello World"));
5204 assertEquals("<script>alert('xss')</script>", sanitize("<script>alert('xss')</script>"));
5205 assertEquals("Hello <b>World</b>", sanitize("Hello <b>World</b>"));
5206 assertEquals("<img src="x" onerror="alert(1)">", sanitize("<img src=\"x\" onerror=\"alert(1)\">"));
5207 }
5208
5209
5210
5211
5212 @Test
5213 void a177_similarity() {
5214 assertEquals(1.0, similarity("hello", "hello"), 0.0001);
5215 assertEquals(0.0, similarity("abc", "xyz"), 0.0001);
5216
5217 assertEquals(4.0 / 7.0, similarity("kitten", "sitting"), 0.01);
5218 assertEquals(1.0, similarity("", ""), 0.0001);
5219 assertEquals(0.0, similarity("abc", ""), 0.0001);
5220 assertEquals(0.0, similarity("", "abc"), 0.0001);
5221
5222 assertEquals(1.0, similarity(null, null), 0.0001);
5223 assertEquals(0.0, similarity("hello", null), 0.0001);
5224 assertEquals(0.0, similarity(null, "hello"), 0.0001);
5225
5226
5227 assertEquals(0.8, similarity("hello", "hallo"), 0.01);
5228
5229
5230
5231
5232 assertEquals(1.0, similarity("", ""), 0.0001);
5233 }
5234
5235
5236
5237
5238
5239
5240
5241
5242 @Test
5243 void a178_skipCommentsStringReader() throws IOException {
5244
5245 var r1 = new StringReader("/*comment*/rest");
5246 r1.read();
5247 skipComments(r1);
5248 var sb1 = new StringBuilder();
5249 int c;
5250 while ((c = r1.read()) != -1)
5251 sb1.append((char)c);
5252 assertEquals("rest", sb1.toString());
5253
5254
5255 var r2 = new StringReader("//comment\nrest");
5256 r2.read();
5257 skipComments(r2);
5258 var sb2 = new StringBuilder();
5259 while ((c = r2.read()) != -1)
5260 sb2.append((char)c);
5261 assertEquals("rest", sb2.toString());
5262
5263
5264 var r3 = new StringReader("//comment");
5265 r3.read();
5266 skipComments(r3);
5267 assertEquals(-1, r3.read());
5268
5269
5270 var r5 = new StringReader("/*unclosed");
5271 r5.read();
5272 skipComments(r5);
5273 assertEquals(-1, r5.read());
5274
5275
5276 var r6 = new StringReader("//comment\nmore//another");
5277 r6.read();
5278 skipComments(r6);
5279 var sb6 = new StringBuilder();
5280 while ((c = r6.read()) != -1)
5281 sb6.append((char)c);
5282 assertEquals("more//another", sb6.toString());
5283 }
5284
5285
5286
5287
5288 @Test
5289 void a180_snakeCase() {
5290 assertNull(snakeCase(null));
5291 assertEquals("", snakeCase(""));
5292 assertEquals("hello_world", snakeCase("hello world"));
5293 assertEquals("hello_world", snakeCase("helloWorld"));
5294 assertEquals("hello_world", snakeCase("HelloWorld"));
5295 assertEquals("hello_world", snakeCase("hello-world"));
5296 assertEquals("hello_world", snakeCase("hello_world"));
5297 assertEquals("xml_http_request", snakeCase("XMLHttpRequest"));
5298 assertEquals("hello_world_test", snakeCase("Hello_World-Test"));
5299 assertEquals("test", snakeCase("test"));
5300 assertEquals("test", snakeCase("TEST"));
5301 assertEquals("hello_123_world", snakeCase("hello 123 world"));
5302
5303
5304
5305 assertEquals("", snakeCase(" "));
5306 assertEquals("", snakeCase("___"));
5307 assertEquals("", snakeCase("---"));
5308 assertEquals("", snakeCase("\t\t"));
5309 }
5310
5311
5312
5313
5314 @Test
5315 void a181_sort() {
5316 assertNull(sort(null));
5317 assertList(sort(a()));
5318 assertList(sort(a("c", "a", "b")), "a", "b", "c");
5319 assertList(sort(a("zebra", "apple", "banana")), "apple", "banana", "zebra");
5320 assertList(sort(a("3", "1", "2")), "1", "2", "3");
5321 assertList(sort(a("test")), "test");
5322 assertList(sort(a("Z", "a", "B")), "B", "Z", "a");
5323 assertList(sort(a("foo", "bar", "baz")), "bar", "baz", "foo");
5324 }
5325
5326
5327
5328
5329 @Test
5330 void a182_sortIgnoreCase() {
5331 assertNull(sortIgnoreCase(null));
5332 assertList(sortIgnoreCase(a()));
5333 assertList(sortIgnoreCase(a("c", "a", "b")), "a", "b", "c");
5334 assertList(sortIgnoreCase(a("Zebra", "apple", "Banana")), "apple", "Banana", "Zebra");
5335 assertList(sortIgnoreCase(a("Z", "a", "B")), "a", "B", "Z");
5336 assertList(sortIgnoreCase(a("test")), "test");
5337 assertList(sortIgnoreCase(a("FOO", "bar", "Baz")), "bar", "Baz", "FOO");
5338 assertList(sortIgnoreCase(a("zebra", "APPLE", "banana")), "APPLE", "banana", "zebra");
5339 }
5340
5341
5342
5343
5344 @Test
5345 void a183_soundex() {
5346
5347 var code1 = soundex("Smith");
5348 assertNotNull(code1);
5349 assertEquals(4, code1.length());
5350 assertTrue(code1.matches("[A-Z]\\d{3}"));
5351
5352 var code2 = soundex("Smythe");
5353 assertNotNull(code2);
5354
5355 assertEquals(code1.charAt(0), code2.charAt(0));
5356
5357
5358 assertNull(soundex(null));
5359 assertNull(soundex(""));
5360
5361
5362 var code3 = soundex("A");
5363 assertNotNull(code3);
5364 assertEquals(4, code3.length());
5365 assertTrue(code3.startsWith("A"));
5366
5367
5368 var code4 = soundex("BFPV");
5369 assertNotNull(code4);
5370 assertTrue(code4.contains("1"));
5371
5372 var code5 = soundex("CGJKQSXZ");
5373 assertNotNull(code5);
5374 assertTrue(code5.contains("2"));
5375
5376 var code6 = soundex("DT");
5377 assertNotNull(code6);
5378 assertTrue(code6.contains("3"));
5379
5380 var code7 = soundex("L");
5381 assertNotNull(code7);
5382
5383 assertEquals("L000", code7);
5384
5385
5386 var code7b = soundex("AL");
5387 assertNotNull(code7b);
5388 assertTrue(code7b.contains("4"));
5389
5390 var code8 = soundex("MN");
5391 assertNotNull(code8);
5392 assertTrue(code8.contains("5"));
5393
5394 var code9 = soundex("R");
5395 assertNotNull(code9);
5396
5397 assertEquals("R000", code9);
5398
5399
5400 var code9b = soundex("AR");
5401 assertNotNull(code9b);
5402 assertTrue(code9b.contains("6"));
5403
5404 var code10 = soundex("AEIOUHWY");
5405 assertNotNull(code10);
5406
5407
5408
5409 var code11 = soundex("A123");
5410 assertNotNull(code11);
5411 assertTrue(code11.startsWith("A"));
5412
5413
5414
5415
5416 var code12 = soundex("A");
5417 assertEquals("A000", code12);
5418
5419
5420 var code13 = soundex("AH");
5421 assertEquals("A000", code13);
5422
5423
5424 var code14 = soundex("ABC");
5425 assertEquals("A120", code14);
5426
5427
5428 var code15 = soundex("ABCD");
5429 assertEquals("A123", code15);
5430
5431
5432 var code16 = soundex("ABBC");
5433 assertEquals("A120", code16);
5434
5435
5436
5437 var code17 = soundex("ABCDEFGHIJKLMNOP");
5438 assertEquals("A123", code17);
5439 assertEquals(4, code17.length());
5440
5441
5442
5443
5444
5445 var code18 = soundex("AB");
5446 assertEquals("A100", code18);
5447
5448
5449 }
5450
5451
5452
5453
5454 @Test
5455 void a184_split() {
5456
5457 assertEquals(Collections.emptyList(), split(null));
5458 assertTrue(split("").isEmpty());
5459 assertEquals(List.of("1"), split("1"));
5460 assertEquals(List.of("1", "2"), split("1,2"));
5461
5462
5463 assertNull(split(null, ','));
5464 assertTrue(split("", ',').isEmpty());
5465 assertEquals(List.of("1"), split("1", ','));
5466 assertEquals(List.of("1", "2"), split("1,2", ','));
5467 assertEquals(List.of("1,2"), split("1\\,2", ','));
5468 assertEquals(List.of("1\\", "2"), split("1\\\\,2", ','));
5469 assertEquals(List.of("1\\,2"), split("1\\\\\\,2", ','));
5470 assertEquals(List.of("1", "2\\"), split("1,2\\", ','));
5471 assertEquals(List.of("1", "2\\"), split("1,2\\\\", ','));
5472 assertEquals(List.of("1", "2,"), split("1,2\\,", ','));
5473 assertEquals(List.of("1", "2\\", ""), split("1,2\\\\,", ','));
5474
5475
5476 assertEquals(List.of("boo", "and", "foo"), split("boo:and:foo", ':', 10));
5477 assertEquals(List.of("boo", "and:foo"), split("boo:and:foo", ':', 2));
5478 assertEquals(List.of("boo:and:foo"), split("boo:and:foo", ':', 1));
5479 assertEquals(List.of("boo:and:foo"), split("boo:and:foo", ':', 0));
5480 assertEquals(List.of("boo:and:foo"), split("boo:and:foo", ':', -1));
5481 assertEquals(List.of("boo", "and", "foo"), split("boo : and : foo", ':', 10));
5482 assertEquals(List.of("boo", "and : foo"), split("boo : and : foo", ':', 2));
5483
5484
5485 var list1 = new ArrayList<String>();
5486 split(null, list1::add);
5487 assertTrue(list1.isEmpty());
5488
5489 var list2 = new ArrayList<String>();
5490 split("", list2::add);
5491 assertTrue(list2.isEmpty());
5492
5493 var list3 = new ArrayList<String>();
5494 split("1,2", list3::add);
5495 assertEquals(List.of("1", "2"), list3);
5496
5497
5498 var list4 = new ArrayList<String>();
5499 split("no-commas-here", ',', list4::add);
5500 assertEquals(List.of("no-commas-here"), list4);
5501
5502
5503
5504 var list5 = new ArrayList<String>();
5505 split("a\\,b,c", ',', list5::add);
5506 assertEquals(List.of("a,b", "c"), list5);
5507
5508 var list6 = new ArrayList<String>();
5509 split("a\\\\,b", ',', list6::add);
5510 assertEquals(List.of("a\\", "b"), list6);
5511
5512 var list7 = new ArrayList<String>();
5513 split("a\\b,c", ',', list7::add);
5514 assertEquals(List.of("a\\b", "c"), list7);
5515
5516
5517 assertNull(splita((String)null));
5518 assertArrayEquals(new String[0], splita(""));
5519 assertArrayEquals(new String[] { "1" }, splita("1"));
5520 assertArrayEquals(new String[] { "1", "2" }, splita("1,2"));
5521
5522
5523 assertNull(splita((String)null, ','));
5524 assertArrayEquals(new String[0], splita("", ','));
5525 assertArrayEquals(new String[] { "1" }, splita("1", ','));
5526 assertArrayEquals(new String[] { "1", "2" }, splita("1,2", ','));
5527
5528
5529 assertArrayEquals(new String[] { "boo", "and", "foo" }, splita("boo:and:foo", ':', 10));
5530 assertArrayEquals(new String[] { "boo", "and:foo" }, splita("boo:and:foo", ':', 2));
5531 assertArrayEquals(new String[] { "boo:and:foo" }, splita("boo:and:foo", ':', 1));
5532 }
5533
5534
5535
5536
5537 @Test
5538 void a185_splitaStringArray() {
5539
5540 String[] nullArray = null;
5541 assertNull(splita(nullArray, ','));
5542
5543
5544 assertArrayEquals(new String[0], splita(new String[0], ','));
5545
5546
5547 String[] array1 = new String[]{"a", "b", "c"};
5548 assertArrayEquals(new String[]{"a", "b", "c"}, splita(array1, ','));
5549
5550
5551 String[] array2 = new String[]{"a,b", "c"};
5552 assertArrayEquals(new String[]{"a", "b", "c"}, splita(array2, ','));
5553 String[] array3 = new String[]{"a,b", "c,d"};
5554 assertArrayEquals(new String[]{"a", "b", "c", "d"}, splita(array3, ','));
5555
5556
5557 String[] array4 = new String[]{"a", null, "c"};
5558 assertArrayEquals(new String[]{"a", null, "c"}, splita(array4, ','));
5559
5560
5561 String[] array5 = new String[]{"a,b,c"};
5562 assertArrayEquals(new String[]{"a", "b", "c"}, splita(array5, ','));
5563 String[] array6 = new String[]{"a,b", "c,d,e"};
5564 assertArrayEquals(new String[]{"a", "b", "c", "d", "e"}, splita(array6, ','));
5565
5566
5567 String[] array7 = new String[]{"a|b|c"};
5568 assertArrayEquals(new String[]{"a", "b", "c"}, splita(array7, '|'));
5569 String[] array8 = new String[]{"a;b;c"};
5570 assertArrayEquals(new String[]{"a", "b", "c"}, splita(array8, ';'));
5571
5572
5573 String[] array9 = new String[]{"a,b", "c", "d"};
5574 assertArrayEquals(new String[]{"a", "b", "c", "d"}, splita(array9, ','));
5575
5576
5577 String[] array10 = new String[]{"a,b", "c,d"};
5578 assertArrayEquals(new String[]{"a", "b", "c", "d"}, splita(array10, ','));
5579 }
5580
5581
5582
5583
5584 @Test
5585 void a186_splitMap() {
5586 assertString("{a=1}", splitMap("a=1", true));
5587 assertString("{a=1,b=2}", splitMap("a=1,b=2", true));
5588 assertString("{a=1,b=2}", splitMap(" a = 1 , b = 2 ", true));
5589 assertString("{ a = 1 , b = 2 }", splitMap(" a = 1 , b = 2 ", false));
5590 assertString("{a=}", splitMap("a", true));
5591 assertString("{a=,b=}", splitMap("a,b", true));
5592 assertString("{a=1,b=}", splitMap("a=1,b", true));
5593 assertString("{a=,b=1}", splitMap("a,b=1", true));
5594 assertString("{a==1}", splitMap("a\\==1", true));
5595 assertString("{a\\=1}", splitMap("a\\\\=1", true));
5596
5597
5598 assertNull(splitMap(null, true));
5599
5600
5601 assertTrue(splitMap("", true).isEmpty());
5602
5603
5604 assertString("{key=}", splitMap(" key ", true));
5605 assertString("{ key =}", splitMap(" key ", false));
5606
5607
5608 assertString("{a=1,b=2}", splitMap("a=1,b=2", true));
5609 assertString("{a=1}", splitMap("a=1", true));
5610 }
5611
5612
5613
5614
5615 @Test
5616 void a187_splitMethodArgs() {
5617
5618 var args1 = splitMethodArgs("a,b,c");
5619 assertEquals(3, args1.length);
5620 assertEquals("a", args1[0]);
5621 assertEquals("b", args1[1]);
5622 assertEquals("c", args1[2]);
5623
5624
5625 var args2 = splitMethodArgs("x,y<a,b>,z");
5626 assertEquals(3, args2.length);
5627 assertEquals("x", args2[0]);
5628 assertEquals("y<a,b>", args2[1]);
5629 assertEquals("z", args2[2]);
5630
5631
5632 var args3 = splitMethodArgs("x,y<a<b,c>,d<e,f>>,z");
5633 assertEquals(3, args3.length);
5634 assertEquals("x", args3[0]);
5635 assertEquals("y<a<b,c>,d<e,f>>", args3[1]);
5636
5637
5638 var args4 = splitMethodArgs("singleArg");
5639 assertEquals(1, args4.length);
5640 assertEquals("singleArg", args4[0]);
5641 assertEquals("z", args3[2]);
5642
5643
5644 assertNull(splitMethodArgs(null));
5645 assertArrayEquals(new String[0], splitMethodArgs(""));
5646 }
5647
5648
5649
5650
5651 @Test
5652 void a188_splitNested() {
5653
5654 var result1 = splitNested("a,b,c");
5655 assertEquals(3, result1.size());
5656 assertEquals("a", result1.get(0));
5657 assertEquals("b", result1.get(1));
5658 assertEquals("c", result1.get(2));
5659
5660
5661 var result2 = splitNested("a{b,c},d");
5662 assertEquals(2, result2.size());
5663 assertEquals("a{b,c}", result2.get(0));
5664 assertEquals("d", result2.get(1));
5665
5666
5667 var result3 = splitNested("a,b{c,d{e,f}}");
5668 assertEquals(2, result3.size());
5669 assertEquals("a", result3.get(0));
5670 assertEquals("b{c,d{e,f}}", result3.get(1));
5671
5672
5673 assertNull(splitNested(null));
5674 assertTrue(splitNested("").isEmpty());
5675
5676
5677
5678 var result4 = splitNested("a\\\\,b");
5679 assertEquals(2, result4.size());
5680 assertEquals("a\\", result4.get(0));
5681 assertEquals("b", result4.get(1));
5682
5683
5684
5685
5686
5687
5688 var result5 = splitNested("a\\,b,c");
5689 assertEquals(1, result5.size());
5690 assertEquals("a,b,c", result5.get(0));
5691
5692
5693
5694
5695
5696 var result6 = splitNested("a\\{b},c");
5697 assertEquals(1, result6.size());
5698 assertEquals("a\\{b},c", result6.get(0));
5699 }
5700
5701
5702
5703
5704 @Test
5705 void a189_splitNestedInner() {
5706
5707 var result1 = splitNestedInner("a{b}");
5708 assertEquals(1, result1.size());
5709 assertEquals("b", result1.get(0));
5710
5711
5712 var result2 = splitNestedInner("a{b,c}");
5713 assertEquals(2, result2.size());
5714 assertEquals("b", result2.get(0));
5715 assertEquals("c", result2.get(1));
5716
5717
5718 var result3 = splitNestedInner("a{b{c,d},e{f,g}}");
5719 assertEquals(2, result3.size());
5720 assertEquals("b{c,d}", result3.get(0));
5721 assertEquals("e{f,g}", result3.get(1));
5722
5723
5724 assertThrows(IllegalArgumentException.class, () -> splitNestedInner(null));
5725 assertThrows(IllegalArgumentException.class, () -> splitNestedInner(""));
5726
5727
5728 assertThrows(IllegalArgumentException.class, () -> splitNestedInner("no braces here"));
5729
5730
5731 assertThrows(IllegalArgumentException.class, () -> splitNestedInner("a{b"));
5732 assertThrows(IllegalArgumentException.class, () -> splitNestedInner("a{b{c}"));
5733
5734
5735
5736 var result4 = splitNestedInner("a{b\\\\,c}");
5737 assertEquals(2, result4.size());
5738 assertEquals("b\\", result4.get(0));
5739 assertEquals("c", result4.get(1));
5740
5741
5742
5743
5744
5745
5746
5747
5748 var result5 = splitNestedInner("a{b\\,c\\}");
5749 assertEquals(1, result5.size());
5750 assertEquals("b,c\\", result5.get(0));
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761 }
5762
5763
5764
5765
5766 @Test
5767 void a190_splitQuoted() {
5768 assertNull(splitQuoted(null));
5769 assertEmpty(splitQuoted(""));
5770 assertEmpty(splitQuoted(" \t "));
5771 assertList(splitQuoted("foo"), "foo");
5772 assertList(splitQuoted("foo bar baz"), "foo", "bar", "baz");
5773 assertList(splitQuoted("'foo'"), "foo");
5774 assertList(splitQuoted(" ' foo ' "), " foo ");
5775 assertList(splitQuoted("'foo' 'bar'"), "foo", "bar");
5776 assertList(splitQuoted("\"foo\""), "foo");
5777 assertList(splitQuoted(" \" foo \" "), " foo ");
5778 assertList(splitQuoted("\"foo\" \"bar\""), "foo", "bar");
5779 assertList(splitQuoted("'foo\\'bar'"), "foo'bar");
5780 assertList(splitQuoted("'foo\\\"bar'"), "foo\"bar");
5781 assertList(splitQuoted("'\\'foo\\'bar\\''"), "'foo'bar'");
5782 assertList(splitQuoted("'\\\"foo\\\"bar\\\"'"), "\"foo\"bar\"");
5783 assertList(splitQuoted("'\\'foo\\''"), "'foo'");
5784 assertList(splitQuoted("\"\\\"foo\\\"\""), "\"foo\"");
5785 assertList(splitQuoted("'\"foo\"'"), "\"foo\"");
5786 assertList(splitQuoted("\"'foo'\""), "'foo'");
5787
5788
5789
5790 var result1 = splitQuoted("'foo'", true);
5791 assertEquals(1, result1.length);
5792 assertEquals("'foo'", result1[0]);
5793
5794
5795 var result2 = splitQuoted("\"bar\"", true);
5796 assertEquals(1, result2.length);
5797 assertEquals("\"bar\"", result2[0]);
5798
5799
5800
5801
5802
5803 var result3 = splitQuoted("'foo\\'bar'", false);
5804 assertEquals(1, result3.length);
5805 assertEquals("foo'bar", result3[0]);
5806
5807 var result4 = splitQuoted("'foo\\'bar'", true);
5808 assertEquals(1, result4.length);
5809 assertEquals("'foo\\'bar'", result4[0]);
5810
5811
5812
5813
5814 var result5a = splitQuoted(" abc");
5815 assertEquals(1, result5a.length);
5816 assertEquals("abc", result5a[0]);
5817
5818 var result5a2 = splitQuoted("abc");
5819 assertEquals(1, result5a2.length);
5820 assertEquals("abc", result5a2[0]);
5821
5822
5823
5824 var result5 = splitQuoted("foo bar");
5825 assertEquals(2, result5.length);
5826 assertEquals("foo", result5[0]);
5827 assertEquals("bar", result5[1]);
5828
5829
5830 var result5b = splitQuoted("foo\tbar");
5831 assertEquals(2, result5b.length);
5832 assertEquals("foo", result5b[0]);
5833 assertEquals("bar", result5b[1]);
5834
5835
5836 assertThrows(IllegalArgumentException.class, () -> splitQuoted("'unmatched quote"));
5837 assertThrows(IllegalArgumentException.class, () -> splitQuoted("\"unmatched quote"));
5838 assertThrows(IllegalArgumentException.class, () -> splitQuoted("'unmatched quote", false));
5839 assertThrows(IllegalArgumentException.class, () -> splitQuoted("\"unmatched quote", true));
5840 }
5841
5842
5843
5844
5845 @Test
5846 void a191_startsWith() {
5847 assertFalse(startsWith(null, 'a'));
5848 assertFalse(startsWith("", 'a'));
5849 assertTrue(startsWith("a", 'a'));
5850 assertTrue(startsWith("ab", 'a'));
5851 assertFalse(startsWith("ba", 'a'));
5852 assertTrue(startsWith("Hello", 'H'));
5853 assertFalse(startsWith("hello", 'H'));
5854 }
5855
5856
5857
5858
5859 @Test
5860 void a192_startsWithIgnoreCase() {
5861 assertTrue(startsWithIgnoreCase("Hello World", "hello"));
5862 assertTrue(startsWithIgnoreCase("Hello World", "HELLO"));
5863 assertTrue(startsWithIgnoreCase("Hello World", "Hello"));
5864 assertTrue(startsWithIgnoreCase("hello world", "HELLO"));
5865 assertFalse(startsWithIgnoreCase("Hello World", "world"));
5866 assertFalse(startsWithIgnoreCase("Hello World", "xyz"));
5867 assertFalse(startsWithIgnoreCase(null, "test"));
5868 assertFalse(startsWithIgnoreCase("test", null));
5869 assertFalse(startsWithIgnoreCase(null, null));
5870 assertTrue(startsWithIgnoreCase("Hello", "hello"));
5871 }
5872
5873
5874
5875
5876 @Test
5877 void a193_stringSupplier() {
5878 var supplier1 = stringSupplier(() -> "test");
5879 assertEquals("test", supplier1.get());
5880
5881 var supplier2 = stringSupplier(() -> 123);
5882 assertEquals("123", supplier2.get());
5883
5884 var supplier3 = stringSupplier(() -> List.of("a", "b", "c"));
5885 assertEquals("[a,b,c]", supplier3.get());
5886
5887
5888 var supplier4 = stringSupplier(() -> null);
5889 assertNull(supplier4.get());
5890 }
5891
5892
5893
5894
5895 @Test
5896 void a194_strip() {
5897 assertNull(strip(null));
5898 assertEquals("", strip(""));
5899
5900
5901 assertEquals("a", strip("a"));
5902 assertEquals("", strip("ab"));
5903
5904 assertEquals("b", strip("abc"));
5905 assertEquals("ell", strip("hello"));
5906 assertEquals("test", strip("xtestx"));
5907 }
5908
5909
5910
5911
5912 @Test
5913 void a195_stripInvalidHttpHeaderChars() {
5914 assertNull(stripInvalidHttpHeaderChars(null));
5915 assertEquals("", stripInvalidHttpHeaderChars(""));
5916
5917 var result1 = stripInvalidHttpHeaderChars("Hello World");
5918 assertTrue(result1.equals("HelloWorld") || result1.equals("Hello World"));
5919
5920 var result2 = stripInvalidHttpHeaderChars("Hello\u0000World");
5921 assertFalse(result2.contains("\u0000"));
5922
5923 var result3 = stripInvalidHttpHeaderChars("Header-Value:123");
5924 assertTrue(result3.contains("Header") && result3.contains("Value"));
5925 }
5926
5927
5928
5929
5930 @Test
5931 void a196_substringAfter() {
5932 assertNull(substringAfter(null, "."));
5933 assertEquals("", substringAfter("hello.world", null));
5934 assertEquals("world", substringAfter("hello.world", "."));
5935 assertEquals("", substringAfter("hello.world", "xyz"));
5936 assertEquals("world", substringAfter("hello.world", "."));
5937 assertEquals("bar.baz", substringAfter("foo.bar.baz", "."));
5938 }
5939
5940
5941
5942
5943 @Test
5944 void a197_substringBefore() {
5945 assertNull(substringBefore(null, "."));
5946 assertEquals("hello.world", substringBefore("hello.world", null));
5947 assertEquals("hello", substringBefore("hello.world", "."));
5948 assertEquals("hello.world", substringBefore("hello.world", "xyz"));
5949 assertEquals("", substringBefore(".world", "."));
5950 assertEquals("foo", substringBefore("foo.bar.baz", "."));
5951 }
5952
5953
5954
5955
5956 @Test
5957 void a198_substringBetween() {
5958 assertNull(substringBetween(null, "<", ">"));
5959 assertNull(substringBetween("<hello>", null, ">"));
5960 assertNull(substringBetween("<hello>", "<", null));
5961 assertEquals("hello", substringBetween("<hello>", "<", ">"));
5962 assertNull(substringBetween("<hello>", "[", "]"));
5963 assertNull(substringBetween("hello", "<", ">"));
5964 assertEquals("", substringBetween("<>", "<", ">"));
5965 assertEquals("test", substringBetween("<test>", "<", ">"));
5966 assertEquals("foo", substringBetween("a<foo>b", "<", ">"));
5967
5968
5969 assertNull(substringBetween("<hello", "<", ">"));
5970 assertNull(substringBetween("start<content", "<", ">"));
5971 }
5972
5973
5974
5975
5976 @Test
5977 void a199_swapCase() {
5978 assertNull(swapCase(null));
5979 assertEquals("", swapCase(""));
5980 assertEquals("hELLO wORLD", swapCase("Hello World"));
5981 assertEquals("abc123XYZ", swapCase("ABC123xyz"));
5982 assertEquals("123", swapCase("123"));
5983 assertEquals("aBc", swapCase("AbC"));
5984 }
5985
5986
5987
5988
5989 @Test
5990 void a200_titleCase() {
5991 assertNull(titleCase(null));
5992 assertEquals("", titleCase(""));
5993 assertEquals("Hello World", titleCase("hello world"));
5994 assertEquals("Hello World", titleCase("helloWorld"));
5995 assertEquals("Hello World", titleCase("HelloWorld"));
5996 assertEquals("Hello World", titleCase("hello_world"));
5997 assertEquals("Hello World", titleCase("hello-world"));
5998 assertEquals("Xml Http Request", titleCase("XMLHttpRequest"));
5999 assertEquals("Hello World Test", titleCase("Hello_World-Test"));
6000 assertEquals("Test", titleCase("test"));
6001 assertEquals("Test", titleCase("TEST"));
6002 assertEquals("Hello 123 World", titleCase("hello 123 world"));
6003
6004
6005
6006 assertEquals("", titleCase(" "));
6007 assertEquals("", titleCase("___"));
6008 assertEquals("", titleCase("---"));
6009 assertEquals("", titleCase("\t\t"));
6010 assertEquals("", titleCase(" _- "));
6011
6012 assertEquals("123", titleCase("123"));
6013
6014 assertEquals("!@#", titleCase("!@#"));
6015 }
6016
6017
6018
6019
6020 @Test
6021 void a201_toCdl() {
6022
6023 assertNull(toCdl(null));
6024
6025
6026 assertEquals("1, 2, 3", toCdl(new int[] { 1, 2, 3 }));
6027 assertEquals("a, b, c", toCdl(new String[] { "a", "b", "c" }));
6028 assertEquals("", toCdl(new String[] {}));
6029
6030
6031 assertEquals("1, 2, 3", toCdl(List.of(1, 2, 3)));
6032 assertEquals("a, b, c", toCdl(List.of("a", "b", "c")));
6033 assertEquals("", toCdl(List.of()));
6034
6035
6036 assertEquals("test", toCdl("test"));
6037 assertEquals("123", toCdl(123));
6038 }
6039
6040
6041
6042
6043 @Test
6044 void a202_toHex() {
6045
6046 assertEquals("00", toHex((byte)0));
6047 assertEquals("FF", toHex((byte)-1));
6048 assertEquals("0A", toHex((byte)10));
6049 assertEquals("7F", toHex((byte)127));
6050 assertEquals("80", toHex((byte)-128));
6051
6052
6053 assertEquals("", toHex(new byte[] {}));
6054 assertEquals("000102", toHex(new byte[] { 0, 1, 2 }));
6055 assertEquals("FFFE", toHex(new byte[] { (byte)255, (byte)254 }));
6056 assertEquals("48656C6C6F", toHex("Hello".getBytes()));
6057 }
6058
6059
6060
6061
6062 @Test
6063 void a203_toHex2() {
6064
6065 assertString("00", toHex2(0));
6066
6067
6068 assertString("01", toHex2(1));
6069 assertString("0F", toHex2(15));
6070 assertString("10", toHex2(16));
6071 assertString("FF", toHex2(255));
6072
6073
6074 assertString("FF", toHex2(255));
6075
6076
6077 assertThrowsWithMessage(NumberFormatException.class, "toHex2 can only be used on numbers between 0 and 255", () -> toHex2(256));
6078 assertThrowsWithMessage(NumberFormatException.class, "toHex2 can only be used on numbers between 0 and 255", () -> toHex2(-1));
6079
6080
6081 assertString("0A", toHex2(10));
6082 }
6083
6084
6085
6086
6087 @Test
6088 void a204_toHex4() {
6089
6090 assertString("0000", toHex4(0));
6091
6092
6093 assertString("0001", toHex4(1));
6094 assertString("000F", toHex4(15));
6095 assertString("0010", toHex4(16));
6096 assertString("00FF", toHex4(255));
6097
6098
6099 assertString("0100", toHex4(256));
6100 assertString("1000", toHex4(4096));
6101 assertString("FFFF", toHex4(65535));
6102
6103
6104 assertString("0000", toHex4(65536));
6105
6106
6107 assertThrowsWithMessage(NumberFormatException.class, "toHex4 can only be used on non-negative numbers", () -> toHex4(-1));
6108 }
6109
6110
6111
6112
6113 @Test
6114 void a205_toHex8() {
6115
6116 assertString("00000000", toHex8(0));
6117
6118
6119 assertString("00000001", toHex8(1));
6120 assertString("000000FF", toHex8(255));
6121 assertString("0000FFFF", toHex8(65535));
6122 assertString("FFFFFFFF", toHex8(0xFFFFFFFFL));
6123
6124
6125 assertString("00000000", toHex8(0x100000000L));
6126
6127
6128 assertThrowsWithMessage(NumberFormatException.class, "toHex8 can only be used on non-negative numbers", () -> toHex8(-1));
6129 }
6130
6131
6132
6133
6134 @Test
6135 void a206_toHexInputStream() throws Exception {
6136
6137 assertNull(toHex((java.io.InputStream)null));
6138
6139
6140 var emptyStream = new java.io.ByteArrayInputStream(new byte[0]);
6141 assertEquals("", toHex(emptyStream));
6142
6143
6144 var singleByte = new java.io.ByteArrayInputStream(new byte[]{0x41});
6145 assertEquals("41", toHex(singleByte));
6146
6147
6148 var multiByte = new java.io.ByteArrayInputStream(new byte[]{0x41, 0x42, 0x43});
6149 assertEquals("414243", toHex(multiByte));
6150
6151
6152 var variousBytes = new java.io.ByteArrayInputStream(new byte[]{(byte)0xFF, (byte)0x00, (byte)0x0A});
6153 assertEquals("FF000A", toHex(variousBytes));
6154
6155
6156 var largeBytes = new byte[100];
6157 java.util.Arrays.fill(largeBytes, (byte)0x42);
6158 var largeStream = new java.io.ByteArrayInputStream(largeBytes);
6159 var result = toHex(largeStream);
6160 assertNotNull(result);
6161 assertEquals(200, result.length());
6162 assertTrue(result.matches("^(42)+$"));
6163 }
6164
6165
6166
6167
6168 @Test
6169 void a207_toIsoDate() {
6170 assertNull(toIsoDate(null));
6171
6172
6173 var cal = Calendar.getInstance();
6174 cal.set(2023, Calendar.DECEMBER, 25, 10, 30, 0);
6175 cal.set(Calendar.MILLISECOND, 0);
6176 cal.setTimeZone(TimeZone.getTimeZone("UTC"));
6177
6178 var result = toIsoDate(cal);
6179 assertEquals("2023-12-25", result);
6180 }
6181
6182
6183
6184
6185 @Test
6186 void a208_toIsoDateTime() {
6187 assertNull(toIsoDateTime(null));
6188
6189
6190 var cal = Calendar.getInstance();
6191 cal.set(2023, Calendar.DECEMBER, 25, 10, 30, 0);
6192 cal.set(Calendar.MILLISECOND, 0);
6193 cal.setTimeZone(TimeZone.getTimeZone("UTC"));
6194
6195 var result = toIsoDateTime(cal);
6196
6197 assertTrue(result.startsWith("2023-12-25T10:30:00"));
6198 }
6199
6200
6201
6202
6203 @Test
6204 void a209_toReadableBytes() {
6205
6206 var bytes1 = "Hello".getBytes();
6207 var result1 = toReadableBytes(bytes1);
6208
6209 assertTrue(result1.length() > 0);
6210 assertTrue(result1.contains("[48]"));
6211
6212
6213 var bytes2 = new byte[] { 0, 1, 2, (byte)255 };
6214 var result2 = toReadableBytes(bytes2);
6215
6216
6217 var bytes3 = new byte[]{0x00, 0x1F, 0x20, 0x7A, 0x7B, (byte)0xFF};
6218 var result3 = toReadableBytes(bytes3);
6219 assertTrue(result3.contains("[00]"));
6220 assertTrue(result3.contains("[1F]"));
6221 assertTrue(result3.contains("[FF]"));
6222 assertTrue(result3.contains(" "));
6223 assertTrue(result2.contains("[00]"));
6224 assertTrue(result2.contains("[FF]"));
6225 }
6226
6227
6228
6229
6230 @Test
6231 void a208_toSpacedHex() {
6232 assertEquals("", toSpacedHex(new byte[] {}));
6233 assertEquals("00 01 02", toSpacedHex(new byte[] { 0, 1, 2 }));
6234 assertEquals("FF FE", toSpacedHex(new byte[] { (byte)255, (byte)254 }));
6235 assertEquals("48 65 6C 6C 6F", toSpacedHex("Hello".getBytes()));
6236 }
6237
6238
6239
6240
6241 @Test
6242 void a209_toString() {
6243
6244 assertNull(StringUtils.toString(null));
6245 assertEquals("hello", StringUtils.toString("hello"));
6246 assertEquals("123", StringUtils.toString(123));
6247 assertEquals("true", StringUtils.toString(true));
6248 assertEquals("1.5", StringUtils.toString(1.5));
6249
6250
6251 assertEquals("default", StringUtils.toString(null, "default"));
6252 assertEquals("hello", StringUtils.toString("hello", "default"));
6253 assertEquals("123", StringUtils.toString(123, "default"));
6254 assertEquals("true", StringUtils.toString(true, "default"));
6255
6256
6257 assertNull(StringUtils.toString(null, null));
6258 assertEquals("hello", StringUtils.toString("hello", null));
6259
6260
6261 assertEquals("", StringUtils.toString(null, ""));
6262 assertEquals("hello", StringUtils.toString("hello", ""));
6263 }
6264
6265
6266
6267
6268 @Test
6269 void a210_toStringArray() {
6270 assertNull(toStringArray(null));
6271 assertList(toStringArray(Collections.emptyList()));
6272 assertList(toStringArray(List.of("a", "b", "c")), "a", "b", "c");
6273
6274
6275 var set = new LinkedHashSet<String>();
6276 set.add("x");
6277 set.add("y");
6278 set.add("z");
6279 assertList(toStringArray(set), "x", "y", "z");
6280 }
6281
6282
6283
6284
6285 @Test
6286 void a211_toUri() {
6287
6288 assertNull(toUri(null));
6289
6290
6291 var uri1 = java.net.URI.create("http://example.com");
6292 assertSame(uri1, toUri(uri1));
6293
6294
6295 var uri2 = toUri("http://example.com");
6296 assertNotNull(uri2);
6297 assertEquals("http://example.com", uri2.toString());
6298
6299
6300 assertThrows(RuntimeException.class, () -> toUri("not a valid uri"));
6301 }
6302
6303
6304
6305
6306 @Test
6307 void a212_toUtf8() {
6308
6309 assertNull(toUtf8((byte[])null));
6310 assertEquals("", toUtf8(new byte[] {}));
6311 assertEquals("Hello", toUtf8("Hello".getBytes(UTF8)));
6312 assertEquals("Test 123", toUtf8("Test 123".getBytes(UTF8)));
6313
6314
6315 assertNull(toUtf8((java.io.InputStream)null));
6316 var is = new java.io.ByteArrayInputStream("Hello World".getBytes(UTF8));
6317 assertEquals("Hello World", toUtf8(is));
6318 }
6319
6320
6321
6322
6323 @Test
6324 void a213_transliterate() {
6325
6326 assertNull(transliterate(null, "abc", "xyz"));
6327
6328
6329 assertEquals("h2ll4", transliterate("hello", "aeiou", "12345"));
6330 assertEquals("XYZ", transliterate("ABC", "ABC", "XYZ"));
6331
6332
6333 assertEquals("h2ll4 w4rld", transliterate("hello world", "aeiou", "12345"));
6334
6335
6336 assertEquals("hello", transliterate("hello", null, "xyz"));
6337 assertEquals("hello", transliterate("hello", "", "xyz"));
6338 assertEquals("hello", transliterate("hello", "abc", null));
6339 assertEquals("hello", transliterate("hello", "abc", ""));
6340
6341
6342 assertThrows(IllegalArgumentException.class, () -> transliterate("hello", "abc", "xy"));
6343 }
6344
6345
6346
6347
6348 @Test
6349 void a214_trim() {
6350 assertNull(trim(null));
6351 assertEquals("", trim(""));
6352 assertEquals("", trim(" "));
6353 assertEquals("hello", trim(" hello "));
6354 assertEquals("hello world", trim(" hello world "));
6355 assertEquals("test", trim("\t\ntest\r\n"));
6356 }
6357
6358
6359
6360
6361 @Test
6362 void a215_trimEnd() {
6363 assertNull(trimEnd(null));
6364 assertEquals("", trimEnd(""));
6365 assertEquals("", trimEnd(" "));
6366 assertEquals(" hello", trimEnd(" hello "));
6367 assertEquals("hello", trimEnd("hello "));
6368 assertEquals("test", trimEnd("test\r\n"));
6369 }
6370
6371
6372
6373
6374 @Test
6375 void a216_trimLeadingSlashes() {
6376 assertNull(trimLeadingSlashes(null));
6377 assertEquals("", trimLeadingSlashes(""));
6378 assertEquals("", trimLeadingSlashes("/"));
6379 assertEquals("path", trimLeadingSlashes("/path"));
6380 assertEquals("path", trimLeadingSlashes("///path"));
6381 assertEquals("path/", trimLeadingSlashes("/path/"));
6382 assertEquals("path", trimLeadingSlashes("path"));
6383 }
6384
6385
6386
6387
6388 @Test
6389 void a217_trimSlashes() {
6390 assertNull(trimSlashes(null));
6391 assertEquals("", trimSlashes(""));
6392 assertEquals("", trimSlashes("/"));
6393 assertEquals("", trimSlashes("///"));
6394 assertEquals("path", trimSlashes("/path"));
6395 assertEquals("path", trimSlashes("path/"));
6396 assertEquals("path", trimSlashes("/path/"));
6397 assertEquals("path", trimSlashes("///path///"));
6398 assertEquals("path", trimSlashes("path"));
6399 }
6400
6401
6402
6403
6404 @Test
6405 void a218_trimSlashesAndSpaces() {
6406 assertNull(trimSlashesAndSpaces(null));
6407 assertEquals("", trimSlashesAndSpaces(""));
6408 assertEquals("", trimSlashesAndSpaces("/"));
6409 assertEquals("", trimSlashesAndSpaces(" "));
6410 assertEquals("", trimSlashesAndSpaces(" / "));
6411 assertEquals("path", trimSlashesAndSpaces("/path"));
6412 assertEquals("path", trimSlashesAndSpaces("path/"));
6413 assertEquals("path", trimSlashesAndSpaces("/path/"));
6414 assertEquals("path", trimSlashesAndSpaces(" /path/ "));
6415 assertEquals("path", trimSlashesAndSpaces("///path///"));
6416 assertEquals("path", trimSlashesAndSpaces("path"));
6417 }
6418
6419
6420
6421
6422 @Test
6423 void a219_trimStart() {
6424 assertNull(trimStart(null));
6425 assertEquals("", trimStart(""));
6426 assertEquals("", trimStart(" "));
6427 assertEquals("hello ", trimStart(" hello "));
6428 assertEquals("hello", trimStart(" hello"));
6429 assertEquals("test", trimStart("\t\ntest"));
6430 }
6431
6432
6433
6434
6435 @Test
6436 void a220_trimTrailingSlashes() {
6437 assertNull(trimTrailingSlashes(null));
6438 assertEquals("", trimTrailingSlashes(""));
6439 assertEquals("", trimTrailingSlashes("/"));
6440 assertEquals("", trimTrailingSlashes("///"));
6441 assertEquals("/path", trimTrailingSlashes("/path"));
6442 assertEquals("path", trimTrailingSlashes("path/"));
6443 assertEquals("/path", trimTrailingSlashes("/path/"));
6444 assertEquals("/path", trimTrailingSlashes("/path///"));
6445 assertEquals("path", trimTrailingSlashes("path"));
6446 }
6447
6448
6449
6450
6451 @Test
6452 void a221_uncapitalize() {
6453 assertNull(uncapitalize(null));
6454 assertEquals("", uncapitalize(""));
6455 assertEquals("hello", uncapitalize("hello"));
6456 assertEquals("hello", uncapitalize("Hello"));
6457 assertEquals("hELLO", uncapitalize("HELLO"));
6458 assertEquals("a", uncapitalize("A"));
6459 assertEquals("123", uncapitalize("123"));
6460 }
6461
6462
6463
6464
6465 @Test
6466 void a222_unescapeChars() {
6467 var escape = AsciiSet.of("\\,|");
6468
6469 assertNull(unescapeChars(null, escape));
6470 assertEquals("xxx", unescapeChars("xxx", escape));
6471 assertEquals("x,xx", unescapeChars("x\\,xx", escape));
6472 assertEquals("x\\xx", unescapeChars("x\\xx", escape));
6473 assertEquals("x\\,xx", unescapeChars("x\\\\,xx", escape));
6474 assertEquals("x\\,xx", unescapeChars("x\\\\\\,xx", escape));
6475 assertEquals("\\", unescapeChars("\\", escape));
6476 assertEquals(",", unescapeChars("\\,", escape));
6477
6478
6479 assertEquals("x\\y", unescapeChars("x\\\\y", escape));
6480 assertEquals("x\\", unescapeChars("x\\\\", escape));
6481 assertEquals("|", unescapeChars("\\|", escape));
6482
6483
6484
6485 escape = AsciiSet.of(",|");
6486 assertEquals("x\\\\xx", unescapeChars("x\\\\xx", escape));
6487
6488
6489
6490
6491
6492
6493 assertEquals("\\\\", unescapeChars("\\\\", AsciiSet.of(",")));
6494
6495
6496
6497
6498
6499 System.out.println("=== Testing unescapeChars with a\\\\b, backslash NOT in escaped set ===");
6500 var result2 = unescapeChars("a\\\\b", AsciiSet.of(","));
6501 System.out.println("Result: " + java.util.Arrays.toString(result2.toCharArray()));
6502 assertEquals("a\\\\b", result2);
6503 }
6504
6505
6506
6507
6508 @Test
6509 void a223_unescapeHtml() {
6510 assertNull(unescapeHtml(null));
6511 assertEquals("", unescapeHtml(""));
6512 assertEquals("Hello World", unescapeHtml("Hello World"));
6513 assertEquals("<script>", unescapeHtml("<script>"));
6514 assertEquals("\"Hello\"", unescapeHtml(""Hello""));
6515 assertEquals("It's a test", unescapeHtml("It's a test"));
6516 assertEquals("It's a test", unescapeHtml("It's a test"));
6517 assertEquals("&", unescapeHtml("&"));
6518 assertEquals("<tag>text</tag>", unescapeHtml("<tag>text</tag>"));
6519
6520 assertEquals("Hello & World", unescapeHtml(escapeHtml("Hello & World")));
6521 }
6522
6523
6524
6525
6526 @Test
6527 void a224_unescapeXml() {
6528 assertNull(unescapeXml(null));
6529 assertEquals("", unescapeXml(""));
6530 assertEquals("Hello World", unescapeXml("Hello World"));
6531 assertEquals("<tag>", unescapeXml("<tag>"));
6532 assertEquals("\"Hello\"", unescapeXml(""Hello""));
6533 assertEquals("'test'", unescapeXml("'test'"));
6534 assertEquals("&", unescapeXml("&"));
6535 assertEquals("<tag>text</tag>", unescapeXml("<tag>text</tag>"));
6536 }
6537
6538
6539
6540
6541 @Test
6542 void a225_unicodeSequence() {
6543 assertEquals("\\u0041", unicodeSequence('A'));
6544 assertEquals("\\u0061", unicodeSequence('a'));
6545 assertEquals("\\u0030", unicodeSequence('0'));
6546 assertEquals("\\u0000", unicodeSequence('\u0000'));
6547 assertEquals("\\u00FF", unicodeSequence('\u00FF'));
6548 assertEquals("\\uFFFF", unicodeSequence('\uFFFF'));
6549 }
6550
6551
6552
6553
6554 @Test
6555 void a226_upperCase() {
6556 assertNull(upperCase(null));
6557 assertEquals("", upperCase(""));
6558 assertEquals("HELLO", upperCase("hello"));
6559 assertEquals("HELLO WORLD", upperCase("Hello World"));
6560 assertEquals("123", upperCase("123"));
6561 assertEquals("ABC", upperCase("abc"));
6562 }
6563
6564
6565
6566
6567 @Test
6568 void a227_urlDecode() {
6569 assertNull(urlDecode(null));
6570 assertEquals("", urlDecode(""));
6571 assertEquals("Hello World", urlDecode("Hello+World"));
6572 assertEquals("Hello World", urlDecode("Hello%20World"));
6573 assertEquals("test@example.com", urlDecode("test%40example.com"));
6574 assertEquals("a=b&c=d", urlDecode("a%3Db%26c%3Dd"));
6575
6576 assertEquals("Hello", urlDecode("Hello"));
6577 }
6578
6579
6580
6581
6582 @Test
6583 void a228_urlEncode() {
6584 assertNull(urlEncode(null));
6585 assertEquals("", urlEncode(""));
6586 assertEquals("Hello+World", urlEncode("Hello World"));
6587 assertEquals("test%40example.com", urlEncode("test@example.com"));
6588 assertEquals("a%3Db%26c%3Dd", urlEncode("a=b&c=d"));
6589
6590 assertEquals("Hello", urlEncode("Hello"));
6591 assertEquals("test123", urlEncode("test123"));
6592
6593
6594 var result1 = urlEncode("test@example.com");
6595 assertTrue(result1.contains("%40"));
6596
6597
6598 var result2 = urlEncode("café");
6599 assertNotNull(result2);
6600 assertTrue(result2.contains("%"));
6601
6602 var result3 = urlEncode("测试");
6603 assertNotNull(result3);
6604 assertTrue(result3.contains("%"));
6605 }
6606
6607
6608
6609
6610 @Test
6611 void a229_urlEncodeLax() {
6612 assertNull(urlEncodeLax(null));
6613 assertEquals("", urlEncodeLax(""));
6614
6615 assertEquals("Hello+World", urlEncodeLax("Hello World"));
6616
6617 var result1 = urlEncodeLax("test@example.com");
6618 assertNotNull(result1);
6619
6620 assertEquals("Hello", urlEncodeLax("Hello"));
6621 assertEquals("test123", urlEncodeLax("test123"));
6622
6623
6624
6625 var result2 = urlEncodeLax("test#value");
6626 assertNotNull(result2);
6627 assertTrue(result2.contains("%23"));
6628 var result3 = urlEncodeLax("test%value");
6629 assertNotNull(result3);
6630 assertTrue(result3.contains("%25"));
6631 var result4 = urlEncodeLax("test&value");
6632 assertNotNull(result4);
6633 assertTrue(result4.contains("%26"));
6634
6635
6636
6637 var result5 = urlEncodeLax("testévalue");
6638 assertNotNull(result5);
6639 assertTrue(result5.contains("%"));
6640 var result6 = urlEncodeLax("test中文");
6641 assertNotNull(result6);
6642 assertTrue(result6.contains("%"));
6643 var result7 = urlEncodeLax("test🎉");
6644 assertNotNull(result7);
6645 assertTrue(result7.contains("%"));
6646 }
6647
6648
6649
6650
6651 @Test
6652 void a230_urlEncodePath() {
6653
6654 assertNull(urlEncodePath(null));
6655
6656
6657 var result1 = urlEncodePath("/path/to/file");
6658 assertNotNull(result1);
6659 assertTrue(result1.contains("/"));
6660
6661
6662 var result2 = urlEncodePath("path with spaces");
6663 assertNotNull(result2);
6664 assertTrue(result2.contains("+") || result2.contains("%20"));
6665
6666
6667 var result3 = urlEncodePath("file@name");
6668 assertNotNull(result3);
6669
6670
6671 var result4 = urlEncodePath("simplepath");
6672 assertEquals("simplepath", result4);
6673
6674
6675
6676
6677
6678 var emoji = "🎉";
6679 var result5 = urlEncodePath(emoji);
6680 assertNotNull(result5);
6681
6682
6683 assertTrue(result5.length() > 0);
6684
6685 var result5b = urlEncodePath("test🎉file");
6686 assertNotNull(result5b);
6687 assertTrue(result5b.length() > 0);
6688
6689
6690
6691
6692
6693
6694
6695
6696 var result6 = urlEncodePath("test@file");
6697 assertNotNull(result6);
6698
6699
6700 assertTrue(result6.contains("%40") || result6.contains("%"));
6701
6702 var hexPattern = java.util.regex.Pattern.compile("%([0-9A-Fa-f]{2})");
6703 var matcher = hexPattern.matcher(result6);
6704 boolean foundHex = false;
6705 while (matcher.find()) {
6706 foundHex = true;
6707 var hex = matcher.group(1);
6708
6709 assertEquals(hex.toUpperCase(), hex);
6710 }
6711
6712
6713
6714
6715 var result7 = urlEncodePath("test中文");
6716 assertNotNull(result7);
6717 assertTrue(result7.contains("%"));
6718
6719 var matcher2 = hexPattern.matcher(result7);
6720 while (matcher2.find()) {
6721 var hex = matcher2.group(1);
6722
6723 assertEquals(hex.toUpperCase(), hex);
6724 }
6725
6726 if (foundHex) {
6727
6728 assertTrue(result6.equals(result6.toUpperCase()) || result6.matches(".*%[0-9A-F]{2}.*"));
6729 }
6730 }
6731
6732
6733
6734
6735 @Test
6736 void a231_wordCount() {
6737 assertEquals(0, wordCount(null));
6738 assertEquals(0, wordCount(""));
6739 assertEquals(0, wordCount(" "));
6740 assertEquals(1, wordCount("hello"));
6741 assertEquals(2, wordCount("Hello world"));
6742 assertEquals(4, wordCount("The quick brown fox"));
6743 assertEquals(5, wordCount("Hello, world! How are you?"));
6744 assertEquals(3, wordCount("one\ttwo\nthree"));
6745 assertEquals(1, wordCount("hello123"));
6746
6747 assertEquals(1, wordCount("hello_world"));
6748 assertEquals(2, wordCount("hello world"));
6749 }
6750
6751
6752
6753
6754 @Test
6755 void a232_wrap() {
6756
6757 assertNull(wrap(null, 10));
6758 assertEquals("", wrap("", 10));
6759 assertEquals("hello\nworld", wrap("hello world", 10));
6760 assertEquals("hello\nworld\ntest", wrap("hello world test", 10));
6761 assertEquals("hello world", wrap("hello world", 20));
6762 assertEquals("hello\nworld", wrap("hello world", 5));
6763 assertEquals("supercalifragilisticexpialidocious", wrap("supercalifragilisticexpialidocious", 10));
6764 assertEquals("hello\nworld", wrap("hello world", 10));
6765 assertEquals("line1\nline2", wrap("line1\nline2", 10));
6766 assertEquals("a\nb\nc", wrap("a b c", 1));
6767 assertThrows(IllegalArgumentException.class, () -> wrap("test", 0));
6768 assertThrows(IllegalArgumentException.class, () -> wrap("test", -1));
6769
6770
6771 assertNull(wrap(null, 10, "<br>"));
6772 assertEquals("", wrap("", 10, "<br>"));
6773 assertEquals("hello<br>world", wrap("hello world", 10, "<br>"));
6774 assertEquals("hello<br>world<br>test", wrap("hello world test", 10, "<br>"));
6775 assertEquals("hello world", wrap("hello world", 20, "<br>"));
6776 assertEquals("hello<br>world", wrap("hello world", 5, "<br>"));
6777 assertEquals("supercalifragilisticexpialidocious", wrap("supercalifragilisticexpialidocious", 10, "<br>"));
6778 assertEquals("line1<br>line2", wrap("line1\nline2", 10, "<br>"));
6779 assertEquals("a<br>b<br>c", wrap("a b c", 1, "<br>"));
6780 assertThrows(IllegalArgumentException.class, () -> wrap("test", 0, "\n"));
6781 assertThrows(IllegalArgumentException.class, () -> wrap("test", -1, "\n"));
6782 assertThrows(IllegalArgumentException.class, () -> wrap("test", 10, null));
6783
6784
6785 var result1 = wrap("line1\n\nline2", 10, "\n");
6786 assertTrue(result1.contains("\n\n"));
6787
6788
6789
6790 var result2 = wrap("word1 word2", 10, "\n");
6791 assertTrue(result2.contains("word1"));
6792 assertTrue(result2.contains("word2"));
6793
6794 var result2b = wrap("a b c", 10, "\n");
6795 assertTrue(result2b.contains("a"));
6796 assertTrue(result2b.contains("b"));
6797 assertTrue(result2b.contains("c"));
6798
6799 var result2c = wrap(" hello world", 10, "\n");
6800 assertTrue(result2c.contains("hello"));
6801 assertTrue(result2c.contains("world"));
6802
6803 var result2d = wrap("hello world ", 10, "\n");
6804 assertTrue(result2d.contains("hello"));
6805 assertTrue(result2d.contains("world"));
6806
6807 var result2e = wrap(" hello world ", 10, "\n");
6808 assertTrue(result2e.contains("hello"));
6809 assertTrue(result2e.contains("world"));
6810
6811
6812
6813
6814
6815
6816
6817
6818
6819
6820
6821 var result3 = wrap("short verylongword here", 5, "\n");
6822 assertFalse(result3.contains("verylongword"));
6823 for (var line : result3.split("\n")) {
6824 if (! line.isEmpty())
6825 assertTrue(line.length() <= 5);
6826 }
6827
6828
6829
6830 var result3b = wrap("first\nverylongword here", 5, "\n");
6831
6832 assertTrue(result3b.contains("first"));
6833 assertFalse(result3b.contains("verylongword"));
6834
6835
6836
6837
6838 var result3c = wrap("abcdefghijklmno here", 5, "\n");
6839 assertTrue(result3c.contains("abcde"));
6840 assertTrue(result3c.contains("fghij"));
6841 assertTrue(result3c.contains("klmno"));
6842
6843
6844 var result4 = wrap("short word verylongword here", 10, "\n");
6845 assertFalse(result4.contains("verylongword"));
6846 for (var line : result4.split("\n")) {
6847 if (! line.isEmpty())
6848 assertTrue(line.length() <= 10);
6849 }
6850
6851
6852 var result5 = wrap("short word", 20, "\n");
6853 assertEquals("short word", result5);
6854 }
6855 }