source: trunk/NewView/unittests/StringUtilsUnitTests.pas@ 91

Last change on this file since 91 was 82, checked in by RBRi, 19 years ago

file util refactoring and many more unit tests
  • Property svn:eol-style set to native
File size: 30.1 KB
Line 
1Unit StringUtilsUnitTests;
2
3Interface
4
5uses
6 Classes,
7 TestAssert,
8 StringUtilsUnit;
9
10 FUNCTION getStringUtilsUnitTests : TList;
11
12
13Implementation
14
15 PROCEDURE testTSerializableStringList_Construction;
16 VAR
17 tmpResult : TSerializableStringList;
18 BEGIN
19 tmpResult := TSerializableStringList.Create;
20
21 assertEqualsInt('testTSerializableStringList_Construction', 0, tmpResult.getCount);
22
23 tmpResult.Destroy;
24 END;
25
26
27 PROCEDURE testTSerializableStringList_Add;
28 VAR
29 tmpResult : TSerializableStringList;
30 BEGIN
31 tmpResult := TSerializableStringList.Create;
32
33 tmpResult.add('Test');
34 assertEqualsInt('testTSerializableStringList_Add', 1, tmpResult.getCount);
35
36 tmpResult.Destroy;
37 END;
38
39
40 PROCEDURE testTSerializableStringList_Get_Empty;
41 VAR
42 tmpResult : TSerializableStringList;
43 BEGIN
44 tmpResult := TSerializableStringList.Create;
45
46 assertEqualsInt('testTSerializableStringList_Get_Empty', 0, tmpResult.getCount);
47
48 try
49 tmpResult.get(0);
50 except
51 on e:EListError do
52 begin
53 assertEqualsString('testTSerializableStringList_Get', 'TList error exception (EListError) occured', e.message);
54 end;
55 end;
56
57 tmpResult.Destroy;
58 END;
59
60
61 PROCEDURE testTSerializableStringList_Get;
62 VAR
63 tmpResult : TSerializableStringList;
64 BEGIN
65 tmpResult := TSerializableStringList.Create;
66
67 tmpResult.add('First');
68 tmpResult.add('Second');
69 assertEqualsInt('testTSerializableStringList_Get', 2, tmpResult.getCount);
70 assertEqualsString('testTSerializableStringList_Get', 'First', tmpResult.get(0));
71
72 tmpResult.Destroy;
73 END;
74
75
76 PROCEDURE testTSerializableStringList_getSerializedString_Empty;
77 VAR
78 tmpResult : TSerializableStringList;
79 BEGIN
80 tmpResult := TSerializableStringList.Create;
81
82 assertEqualsString('testTSerializableStringList_getSerializedString_Empty', '', tmpResult.getSerializedString);
83
84 tmpResult.Destroy;
85 END;
86
87
88 PROCEDURE testTSerializableStringList_getSerializedString;
89 VAR
90 tmpResult : TSerializableStringList;
91 BEGIN
92 tmpResult := TSerializableStringList.Create;
93
94 tmpResult.add('First');
95 tmpResult.add('Second');
96 assertEqualsString('testTSerializableStringList_getSerializedString', 'First&Second', tmpResult.getSerializedString);
97
98 tmpResult.Destroy;
99 END;
100
101
102 PROCEDURE testTSerializableStringList_getSerializedString_WithBlanks;
103 VAR
104 tmpResult : TSerializableStringList;
105 BEGIN
106 tmpResult := TSerializableStringList.Create;
107
108 tmpResult.add('Fi rst');
109 tmpResult.add('Second');
110 assertEqualsString('testTSerializableStringList_getSerializedString_WithBlanks', 'Fi rst&Second', tmpResult.getSerializedString);
111
112 tmpResult.Destroy;
113 END;
114
115
116 PROCEDURE testTSerializableStringList_getSerializedString_Escaping;
117 VAR
118 tmpResult : TSerializableStringList;
119 BEGIN
120 tmpResult := TSerializableStringList.Create;
121
122 tmpResult.add('F&i"r''st');
123 tmpResult.add('Sec&ond');
124 assertEqualsString('testTSerializableStringList_getSerializedString_WithBlanks', 'F\&i"r''st&Sec\&ond', tmpResult.getSerializedString);
125
126 tmpResult.Destroy;
127 END;
128
129
130 PROCEDURE testTSerializableStringList_readValuesFromSerializedString;
131 VAR
132 tmpResult : TSerializableStringList;
133 tmpSerialized : String;
134 BEGIN
135 tmpResult := TSerializableStringList.Create;
136
137 tmpSerialized := 'First&Second';
138
139 tmpResult.readValuesFromSerializedString(tmpSerialized);
140
141 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString', 2, tmpResult.getCount);
142 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString', 'First', tmpResult.get(0));
143 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString', 'Second', tmpResult.get(1));
144
145 tmpResult.Destroy;
146 END;
147
148
149 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_quoted;
150 VAR
151 tmpResult : TSerializableStringList;
152 tmpSerialized : String;
153 BEGIN
154 tmpResult := TSerializableStringList.Create;
155
156 tmpSerialized := 'Fi\\nrst&Se\&cond';
157
158 tmpResult.readValuesFromSerializedString(tmpSerialized);
159
160 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_quoted', 2, tmpResult.getCount);
161 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_quoted', 'Fi\nrst', tmpResult.get(0));
162 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_quoted', 'Se&cond', tmpResult.get(1));
163
164 tmpResult.Destroy;
165 END;
166
167
168 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_empty;
169 VAR
170 tmpResult : TSerializableStringList;
171 tmpSerialized : String;
172 BEGIN
173 tmpResult := TSerializableStringList.Create;
174
175 tmpSerialized := '';
176
177 tmpResult.readValuesFromSerializedString(tmpSerialized);
178
179 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_empty', 0, tmpResult.getCount);
180
181 tmpResult.Destroy;
182 END;
183
184
185 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_firstempty;
186 VAR
187 tmpResult : TSerializableStringList;
188 tmpSerialized : String;
189 BEGIN
190 tmpResult := TSerializableStringList.Create;
191
192 tmpResult.add('');
193 tmpResult.add('test');
194
195 tmpSerialized := tmpResult.getSerializedString;
196
197 tmpResult.readValuesFromSerializedString(tmpSerialized);
198
199 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_firstempty', 2, tmpResult.getCount);
200 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_firstempty', '', tmpResult.get(0));
201 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_firstempty', 'test', tmpResult.get(1));
202
203 tmpResult.Destroy;
204 END;
205
206
207 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_2;
208 VAR
209 tmpResult : TSerializableStringList;
210 tmpSerialized : String;
211 BEGIN
212 tmpResult := TSerializableStringList.Create;
213
214 tmpResult.add('&test&');
215 tmpResult.add('"test"');
216 tmpResult.add('');
217 tmpResult.add('abc\&');
218 tmpResult.add('\config.sys');
219
220 tmpResult.add('');
221
222 tmpSerialized := tmpResult.getSerializedString;
223
224 tmpResult.readValuesFromSerializedString(tmpSerialized);
225
226 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_2', 6, tmpResult.getCount);
227 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '&test&', tmpResult.get(0));
228 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '"test"', tmpResult.get(1));
229 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '', tmpResult.get(2));
230 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', 'abc\&', tmpResult.get(3));
231 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '\config.sys', tmpResult.get(4));
232 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '', tmpResult.get(5));
233
234 tmpResult.Destroy;
235 END;
236
237
238 // ------------------------------------------------------
239
240
241 PROCEDURE testEscapeAllCharsBy_Empty;
242 VAR
243 tmpResult : String;
244 BEGIN
245 tmpResult := StrEscapeAllCharsBy('', ['b'], '\');
246
247 assertEqualsString('testEscapeAllCharsBy_Empty', '', tmpResult);
248 END;
249
250
251 PROCEDURE testEscapeAllCharsBy_EmptyChars;
252 VAR
253 tmpResult : String;
254 BEGIN
255 tmpResult := StrEscapeAllCharsBy('abcd', [], '\');
256
257 assertEqualsString('testEscapeAllCharsBy_EmptyChars', 'abcd', tmpResult);
258 END;
259
260
261 PROCEDURE testEscapeAllCharsBy;
262 VAR
263 tmpResult : String;
264 BEGIN
265 tmpResult := StrEscapeAllCharsBy('abc', ['b'], '\');
266
267 assertEqualsString('testEscapeAllCharsBy', 'a\bc', tmpResult);
268 END;
269
270
271 PROCEDURE testEscapeAllCharsBy_EscapeEscape;
272 VAR
273 tmpResult : String;
274 BEGIN
275 tmpResult := StrEscapeAllCharsBy('a\bc', ['b'], '\');
276
277 assertEqualsString('testEscapeAllCharsBy_EscapeEscape', 'a\\\bc', tmpResult);
278 END;
279
280
281 // ------------------------------------------------------
282
283
284 PROCEDURE testStrExtractStrings_EmptyReceiver;
285 VAR
286 tmpResult : TStringList;
287 BEGIN
288 tmpResult := TStringList.Create;
289 StrExtractStrings(tmpResult, '', ['x'], '\');
290
291 assertEqualsInt('testStrExtractStrings_EmptyReceiver', 0, tmpResult.count);
292 tmpResult.Destroy;
293 END;
294
295
296 PROCEDURE testStrExtractStrings_OnlyOnePart;
297 VAR
298 tmpResult : TStringList;
299 BEGIN
300 tmpResult := TStringList.Create;
301 StrExtractStrings(tmpResult, 'abcd', ['x'], '\');
302
303 assertEqualsInt('testStrExtractStrings_OnlyOnePart', 1, tmpResult.count);
304 assertEqualsString('testStrExtractStrings_OnlyOnePart', 'abcd', tmpResult[0]);
305
306 tmpResult.Destroy;
307 END;
308
309
310 PROCEDURE testStrExtractStrings_ManyParts;
311 VAR
312 tmpResult : TStringList;
313 BEGIN
314 tmpResult := TStringList.Create;
315 StrExtractStrings(tmpResult, 'abxcd', ['x'], '\');
316
317 assertEqualsInt('testStrExtractStrings_ManyParts', 2, tmpResult.count);
318 assertEqualsString('testStrExtractStrings_ManyParts', 'ab', tmpResult[0]);
319 assertEqualsString('testStrExtractStrings_ManyParts', 'cd', tmpResult[1]);
320
321 tmpResult.Destroy;
322 END;
323
324
325 PROCEDURE testStrExtractStrings_StartWithDelimiter;
326 VAR
327 tmpResult : TStringList;
328 BEGIN
329 tmpResult := TStringList.Create;
330 StrExtractStrings(tmpResult, 'xab', ['x'], '\');
331
332 assertEqualsInt('testStrExtractStrings_StartWithDelimiter', 2, tmpResult.count);
333 assertEqualsString('testStrExtractStrings_StartWithDelimiter', '', tmpResult[0]);
334 assertEqualsString('testStrExtractStrings_StartWithDelimiter', 'ab', tmpResult[1]);
335
336 tmpResult.Destroy;
337 END;
338
339
340 PROCEDURE testStrExtractStrings_EndWithDelimiter;
341 VAR
342 tmpResult : TStringList;
343 BEGIN
344 tmpResult := TStringList.Create;
345 StrExtractStrings(tmpResult, 'abx', ['x'], '\');
346
347 assertEqualsInt('testStrExtractStrings_EndWithDelimiter', 2, tmpResult.count);
348 assertEqualsString('testStrExtractStrings_EndWithDelimiter', 'ab', tmpResult[0]);
349 assertEqualsString('testStrExtractStrings_EndWithDelimiter', '', tmpResult[1]);
350
351 tmpResult.Destroy;
352 END;
353
354
355 PROCEDURE testStrExtractStrings_EmptyPartInside;
356 VAR
357 tmpResult : TStringList;
358 BEGIN
359 tmpResult := TStringList.Create;
360 StrExtractStrings(tmpResult, 'axxb', ['x'], '\');
361
362 assertEqualsInt('testStrExtractStrings_EmptyPartInside', 3, tmpResult.count);
363 assertEqualsString('testStrExtractStrings_EmptyPartInside', 'a', tmpResult[0]);
364 assertEqualsString('testStrExtractStrings_EmptyPartInside', '', tmpResult[1]);
365 assertEqualsString('testStrExtractStrings_EmptyPartInside', 'b', tmpResult[2]);
366
367 tmpResult.Destroy;
368 END;
369
370
371 PROCEDURE testStrExtractStrings_NoDelimiter;
372 VAR
373 tmpResult : TStringList;
374 BEGIN
375 tmpResult := TStringList.Create;
376 StrExtractStrings(tmpResult, 'axxb', [], '\');
377
378 assertEqualsInt('testStrExtractStrings_NoDelimiter', 1, tmpResult.count);
379 assertEqualsString('testStrExtractStrings_NoDelimiter', 'axxb', tmpResult[0]);
380
381 tmpResult.Destroy;
382 END;
383
384
385 PROCEDURE testStrExtractStrings_EscapedDelimiter;
386 VAR
387 tmpResult : TStringList;
388 BEGIN
389 tmpResult := TStringList.Create;
390 StrExtractStrings(tmpResult, 'a\xb', ['x'], '\');
391
392 assertEqualsInt('testStrExtractStrings_EscapedDelimiter', 1, tmpResult.count);
393 assertEqualsString('testStrExtractStrings_EscapedDelimiter', 'axb', tmpResult[0]);
394
395 tmpResult.Destroy;
396 END;
397
398 PROCEDURE testStrExtractStrings_EscapedEscapeChar;
399 VAR
400 tmpResult : TStringList;
401 BEGIN
402 tmpResult := TStringList.Create;
403 StrExtractStrings(tmpResult, 'a\\xb', ['x'], '\');
404
405 assertEqualsInt('testStrExtractStrings_EscapedEscapeChar', 2, tmpResult.count);
406 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'a\', tmpResult[0]);
407 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'b', tmpResult[1]);
408
409 tmpResult.Destroy;
410 END;
411
412
413 // ------------------------------------------------------
414
415
416 PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyReceiver;
417 VAR
418 tmpResult : TStringList;
419 BEGIN
420 tmpResult := TStringList.Create;
421 StrExtractStringsIgnoreEmpty(tmpResult, '', ['x'], '\');
422
423 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyReceiver', 0, tmpResult.count);
424 tmpResult.Destroy;
425 END;
426
427
428 PROCEDURE testStrExtractStringsIgnoreEmpty_OnlyOnePart;
429 VAR
430 tmpResult : TStringList;
431 BEGIN
432 tmpResult := TStringList.Create;
433 StrExtractStringsIgnoreEmpty(tmpResult, 'abcd', ['x'], '\');
434
435 assertEqualsInt('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 1, tmpResult.count);
436 assertEqualsString('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 'abcd', tmpResult[0]);
437
438 tmpResult.Destroy;
439 END;
440
441
442 PROCEDURE testStrExtractStringsIgnoreEmpty_ManyParts;
443 VAR
444 tmpResult : TStringList;
445 BEGIN
446 tmpResult := TStringList.Create;
447 StrExtractStringsIgnoreEmpty(tmpResult, 'abxcd', ['x'], '\');
448
449 assertEqualsInt('testStrExtractStringsIgnoreEmpty_ManyParts', 2, tmpResult.count);
450 assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'ab', tmpResult[0]);
451 assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'cd', tmpResult[1]);
452
453 tmpResult.Destroy;
454 END;
455
456
457 PROCEDURE testStrExtractStringsIgnoreEmpty_StartWithDelimiter;
458 VAR
459 tmpResult : TStringList;
460 BEGIN
461 tmpResult := TStringList.Create;
462 StrExtractStringsIgnoreEmpty(tmpResult, 'xab', ['x'], '\');
463
464 assertEqualsInt('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 1, tmpResult.count);
465 assertEqualsString('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 'ab', tmpResult[0]);
466
467 tmpResult.Destroy;
468 END;
469
470
471 PROCEDURE testStrExtractStringsIgnoreEmpty_EndWithDelimiter;
472 VAR
473 tmpResult : TStringList;
474 BEGIN
475 tmpResult := TStringList.Create;
476 StrExtractStringsIgnoreEmpty(tmpResult, 'abx', ['x'], '\');
477
478 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 1, tmpResult.count);
479 assertEqualsString('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 'ab', tmpResult[0]);
480
481 tmpResult.Destroy;
482 END;
483
484
485 PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyPartInside;
486 VAR
487 tmpResult : TStringList;
488 BEGIN
489 tmpResult := TStringList.Create;
490 StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', ['x'], '\');
491
492 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 2, tmpResult.count);
493 assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'a', tmpResult[0]);
494 assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'b', tmpResult[1]);
495
496 tmpResult.Destroy;
497 END;
498
499
500 PROCEDURE testStrExtractStringsIgnoreEmpty_NoDelimiter;
501 VAR
502 tmpResult : TStringList;
503 BEGIN
504 tmpResult := TStringList.Create;
505 StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', [], '\');
506
507 assertEqualsInt('testStrExtractStringsIgnoreEmpty_NoDelimiter', 1, tmpResult.count);
508 assertEqualsString('testStrExtractStringsIgnoreEmpty_NoDelimiter', 'axxb', tmpResult[0]);
509
510 tmpResult.Destroy;
511 END;
512
513
514 PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedDelimiter;
515 VAR
516 tmpResult : TStringList;
517 BEGIN
518 tmpResult := TStringList.Create;
519 StrExtractStringsIgnoreEmpty(tmpResult, 'a\xb', ['x'], '\');
520
521 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 1, tmpResult.count);
522 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 'axb', tmpResult[0]);
523
524 tmpResult.Destroy;
525 END;
526
527 PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedEscapeChar;
528 VAR
529 tmpResult : TStringList;
530 BEGIN
531 tmpResult := TStringList.Create;
532 StrExtractStringsIgnoreEmpty(tmpResult, 'a\\xb', ['x'], '\');
533
534 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 2, tmpResult.count);
535 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'a\', tmpResult[0]);
536 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'b', tmpResult[1]);
537
538 tmpResult.Destroy;
539 END;
540
541
542 // -------------------------------------------------------------------
543
544
545 PROCEDURE testTrimLeftChars_Empty;
546 VAR
547 tmpResult : String;
548 BEGIN
549 tmpResult := StrTrimLeftChars('', ['b', 'x']);
550
551 assertEqualsString('testTrimLeftChars_Empty', '', tmpResult);
552 END;
553
554
555 PROCEDURE testTrimLeftChars_RemoveAll;
556 VAR
557 tmpResult : String;
558 BEGIN
559 tmpResult := StrTrimLeftChars('bxxxbx', ['b', 'x']);
560
561 assertEqualsString('testTrimLeftChars_RemoveAll', '', tmpResult);
562 END;
563
564
565 PROCEDURE testTrimLeftChars_OneLeft;
566 VAR
567 tmpResult : String;
568 BEGIN
569 tmpResult := StrTrimLeftChars('bxy', ['b', 'x']);
570
571 assertEqualsString('testTrimLeftChars_OneLeft', 'y', tmpResult);
572 END;
573
574
575 PROCEDURE testTrimLeftChars_LeftOnly;
576 VAR
577 tmpResult : String;
578 BEGIN
579 tmpResult := StrTrimLeftChars('bxbxxay', ['b', 'x']);
580
581 assertEqualsString('testTrimLeftChars_LeftOnly', 'ay', tmpResult);
582 END;
583
584
585 PROCEDURE testTrimLeftChars_CharsInside;
586 VAR
587 tmpResult : String;
588 BEGIN
589 tmpResult := StrTrimLeftChars('bxabxvvx', ['b', 'x']);
590
591 assertEqualsString('testTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
592 END;
593
594
595 PROCEDURE testTrimLeftChars_Nothing;
596 VAR
597 tmpResult : String;
598 BEGIN
599 tmpResult := StrTrimLeftChars('acdef', ['b', 'x']);
600
601 assertEqualsString('testTrimLeftChars_Nothing', 'acdef', tmpResult);
602 END;
603
604
605 // -------------------------------------------------------------------
606
607
608 PROCEDURE testTrimRightChars_Empty;
609 VAR
610 tmpResult : String;
611 BEGIN
612 tmpResult := StrTrimRightChars('', ['b', 'x']);
613
614 assertEqualsString('testTrimRightChars_Empty', '', tmpResult);
615 END;
616
617
618 PROCEDURE testTrimRightChars_RemoveAll;
619 VAR
620 tmpResult : String;
621 BEGIN
622 tmpResult := StrTrimRightChars('bxxxbx', ['b', 'x']);
623
624 assertEqualsString('testTrimRightChars_RemoveAll', '', tmpResult);
625 END;
626
627
628 PROCEDURE testTrimRightChars_OneLeft;
629 VAR
630 tmpResult : String;
631 BEGIN
632 tmpResult := StrTrimRightChars('ybx', ['b', 'x']);
633
634 assertEqualsString('testTrimRightChars_OneLeft', 'y', tmpResult);
635 END;
636
637
638 PROCEDURE testTrimRightChars_RightOnly;
639 VAR
640 tmpResult : String;
641 BEGIN
642 tmpResult := StrTrimRightChars('aybxbxx', ['b', 'x']);
643
644 assertEqualsString('testTrimRightChars_RightOnly', 'ay', tmpResult);
645 END;
646
647
648 PROCEDURE testTrimRightChars_CharsInside;
649 VAR
650 tmpResult : String;
651 BEGIN
652 tmpResult := StrTrimRightChars('abxvvxb', ['b', 'x']);
653
654 assertEqualsString('testTrimRightChars_CharsInside', 'abxvv', tmpResult);
655 END;
656
657
658 PROCEDURE testTrimRightChars_Nothing;
659 VAR
660 tmpResult : String;
661 BEGIN
662 tmpResult := StrTrimRightChars('acdef', ['b', 'x']);
663
664 assertEqualsString('testTrimRightChars_Nothing', 'acdef', tmpResult);
665 END;
666
667
668 // -------------------------------------------------------------------
669
670 PROCEDURE testTrimChars_Empty;
671 VAR
672 tmpResult : String;
673 BEGIN
674 tmpResult := StrTrimChars('', ['b', 'x']);
675
676 assertEqualsString('testTrimChars_Empty', '', tmpResult);
677 END;
678
679
680 PROCEDURE testTrimChars_RemoveAll;
681 VAR
682 tmpResult : String;
683 BEGIN
684 tmpResult := StrTrimChars('bxxxbx', ['b', 'x']);
685
686 assertEqualsString('testTrimChars_RemoveAll', '', tmpResult);
687 END;
688
689
690 PROCEDURE testTrimChars_OneLeftFromLeft;
691 VAR
692 tmpResult : String;
693 BEGIN
694 tmpResult := StrTrimChars('bxa', ['b', 'x']);
695
696 assertEqualsString('testTrimChars_OneLeftFromLeft', 'a', tmpResult);
697 END;
698
699
700 PROCEDURE testTrimChars_OneLeftFromRight;
701 VAR
702 tmpResult : String;
703 BEGIN
704 tmpResult := StrTrimChars('abx', ['b', 'x']);
705
706 assertEqualsString('testTrimChars_OneLeftFromRight', 'a', tmpResult);
707 END;
708
709
710 PROCEDURE testTrimChars_LeftOnly;
711 VAR
712 tmpResult : String;
713 BEGIN
714 tmpResult := StrTrimChars('bxbxxay', ['b', 'x']);
715
716 assertEqualsString('testTrimChars_LeftOnly', 'ay', tmpResult);
717 END;
718
719
720 PROCEDURE testTrimChars_RightOnly;
721 VAR
722 tmpResult : String;
723 BEGIN
724 tmpResult := StrTrimChars('aybxbxx', ['b', 'x']);
725
726 assertEqualsString('testTrimChars_LeftOnly', 'ay', tmpResult);
727 END;
728
729
730 PROCEDURE testTrimChars_CharsInside;
731 VAR
732 tmpResult : String;
733 BEGIN
734 tmpResult := StrTrimChars('bxabxvvx', ['b', 'x']);
735
736 assertEqualsString('testTrimChars_CharsInside', 'abxvv', tmpResult);
737 END;
738
739
740 PROCEDURE testTrimChars_Nothing;
741 VAR
742 tmpResult : String;
743 BEGIN
744 tmpResult := StrTrimChars('acdef', ['b', 'x']);
745
746 assertEqualsString('testTrimChars_Nothing', 'acdef', tmpResult);
747 END;
748
749
750 // -------------------------------------------------------------------
751
752
753 PROCEDURE testTrim;
754 VAR
755 tmpResult : String;
756 BEGIN
757 tmpResult := StrTrim(' a bc ');
758
759 assertEqualsString('testTrim', 'a bc', tmpResult);
760 END;
761
762
763 // -------------------------------------------------------------------
764
765
766 PROCEDURE testStrLeft_Empty;
767 VAR
768 tmpResult : String;
769 BEGIN
770 tmpResult := StrLeft('', 1);
771
772 assertEqualsString('testStrLeft_Empty', '', tmpResult);
773 END;
774
775
776 PROCEDURE testStrLeft_Nothing;
777 VAR
778 tmpResult : String;
779 BEGIN
780 tmpResult := StrLeft('abc', 0);
781
782 assertEqualsString('testStrLeft_Nothing', '', tmpResult);
783 END;
784
785
786 PROCEDURE testStrLeft_WholeString;
787 VAR
788 tmpResult : String;
789 BEGIN
790 tmpResult := StrLeft('abc', 3);
791
792 assertEqualsString('testStrLeft_WholeString', 'abc', tmpResult);
793 END;
794
795 PROCEDURE testStrLeft_ToManyRequested;
796 VAR
797 tmpResult : String;
798 BEGIN
799 tmpResult := StrLeft('abc', 5);
800
801 assertEqualsString('testStrLeft_ToManyRequested', 'abc', tmpResult);
802 END;
803
804 PROCEDURE testStrLeft_Part;
805 VAR
806 tmpResult : String;
807 BEGIN
808 tmpResult := StrLeft('abcdef', 2);
809
810 assertEqualsString('testStrLeft_Part', 'ab', tmpResult);
811 END;
812
813 // -------------------------------------------------------------------
814
815
816 PROCEDURE testStrEndsWith_BothEmpty;
817 VAR
818 tmpResult : Boolean;
819 BEGIN
820 tmpResult := StrEndsWith('', '');
821
822 assertTrue('testStrEndsWith_BothEmpty', tmpResult);
823 END;
824
825
826 PROCEDURE testStrEndsWith_StringEmpty;
827 VAR
828 tmpResult : Boolean;
829 BEGIN
830 tmpResult := StrEndsWith('', 'end');
831
832 assertFalse('testStrEndsWith_StringEmpty', tmpResult);
833 END;
834
835
836 PROCEDURE testStrEndsWith_MatchEmpty;
837 VAR
838 tmpResult : Boolean;
839 BEGIN
840 tmpResult := StrEndsWith('test', '');
841
842 assertTrue('testStrEndsWith_MatchEmpty', tmpResult);
843 END;
844
845
846 PROCEDURE testStrEndsWith_StringToShort;
847 VAR
848 tmpResult : Boolean;
849 BEGIN
850 tmpResult := StrEndsWith('test', 'test1');
851
852 assertFalse('testStrEndsWith_StringToShort', tmpResult);
853 END;
854
855
856 PROCEDURE testStrEndsWith_StringEqualLength;
857 VAR
858 tmpResult : Boolean;
859 BEGIN
860 tmpResult := StrEndsWith('test', 'best');
861
862 assertFalse('testStrEndsWith_StringEqualLength', tmpResult);
863 END;
864
865
866 PROCEDURE testStrEndsWith_StringEqualLengthMatch;
867 VAR
868 tmpResult : Boolean;
869 BEGIN
870 tmpResult := StrEndsWith('test', 'test');
871
872 assertTrue('testStrEndsWith_StringEqualLengthMatch', tmpResult);
873 END;
874
875
876 PROCEDURE testStrEndsWith_StringMatch;
877 VAR
878 tmpResult : Boolean;
879 BEGIN
880 tmpResult := StrEndsWith('a simple test', 'test');
881
882 assertTrue('testStrEndsWith_StringMatch', tmpResult);
883 END;
884
885
886 PROCEDURE testStrEndsWith_StringMatchCaseSensitive;
887 VAR
888 tmpResult : Boolean;
889 BEGIN
890 tmpResult := StrEndsWith('a simple tEst', 'test');
891
892 assertFalse('testStrEndsWith_StringMatchCaseSensitive', tmpResult);
893 END;
894
895
896 PROCEDURE testStrEndsWithIgnoringCase_BothEmpty;
897 VAR
898 tmpResult : Boolean;
899 BEGIN
900 tmpResult := StrEndsWithIgnoringCase('', '');
901
902 assertTrue('testStrEndsWithIgnoringCase_BothEmpty', tmpResult);
903 END;
904
905
906 PROCEDURE testStrEndsWithIgnoringCase_StringEmpty;
907 VAR
908 tmpResult : Boolean;
909 BEGIN
910 tmpResult := StrEndsWithIgnoringCase('', 'end');
911
912 assertFalse('testStrEndsWithIgnoringCase_StringEmpty', tmpResult);
913 END;
914
915
916 PROCEDURE testStrEndsWithIgnoringCase_MatchEmpty;
917 VAR
918 tmpResult : Boolean;
919 BEGIN
920 tmpResult := StrEndsWithIgnoringCase('test', '');
921
922 assertTrue('testStrEndsWithIgnoringCase_MatchEmpty', tmpResult);
923 END;
924
925
926 PROCEDURE testStrEndsWithIgnoringCase_StringToShort;
927 VAR
928 tmpResult : Boolean;
929 BEGIN
930 tmpResult := StrEndsWithIgnoringCase('test', 'test1');
931
932 assertFalse('testStrEndsWithIgnoringCase_StringToShort', tmpResult);
933 END;
934
935
936 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLength;
937 VAR
938 tmpResult : Boolean;
939 BEGIN
940 tmpResult := StrEndsWithIgnoringCase('test', 'best');
941
942 assertFalse('testStrEndsWithIgnoringCase_StringEqualLength', tmpResult);
943 END;
944
945
946 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLengthMatch;
947 VAR
948 tmpResult : Boolean;
949 BEGIN
950 tmpResult := StrEndsWithIgnoringCase('test', 'test');
951
952 assertTrue('testStrEndsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
953 END;
954
955
956 PROCEDURE testStrEndsWithIgnoringCase_StringMatch;
957 VAR
958 tmpResult : Boolean;
959 BEGIN
960 tmpResult := StrEndsWithIgnoringCase('a simple test', 'test');
961
962 assertTrue('testStrEndsWithIgnoringCase_StringMatch', tmpResult);
963 END;
964
965
966 PROCEDURE testStrEndsWithIgnoringCase_StringMatchCaseInSensitive;
967 VAR
968 tmpResult : Boolean;
969 BEGIN
970 tmpResult := StrEndsWithIgnoringCase('a simple tEst', 'test');
971
972 assertTrue('testStrEndsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
973 END;
974
975
976 PROCEDURE testLongWordToStr_Zero;
977 VAR
978 tmpResult : String;
979 BEGIN
980 tmpResult := LongWordToStr(0);
981
982 assertEqualsString('testLongWordToStr_Zero', '0', tmpResult);
983 END;
984
985
986 PROCEDURE testLongWordToStr_Four;
987 VAR
988 tmpResult : String;
989 BEGIN
990 tmpResult := LongWordToStr(4);
991
992 assertEqualsString('testLongWordToStr_Four', '4', tmpResult);
993 END;
994
995 PROCEDURE testLongWordToStr_Max;
996 VAR
997 tmpResult : String;
998 BEGIN
999 tmpResult := LongWordToStr(4294967295);
1000
1001 assertEqualsString('testLongWordToStr_Max', '4294967295', tmpResult);
1002 END;
1003
1004
1005
1006 PROCEDURE testBoolToStr_true;
1007 VAR
1008 tmpResult : String;
1009 BEGIN
1010 tmpResult := BoolToStr(true);
1011
1012 assertEqualsString('testBoolToStr_true', 'True', tmpResult);
1013 END;
1014
1015
1016 PROCEDURE testBoolToStr_false;
1017 VAR
1018 tmpResult : String;
1019 BEGIN
1020 tmpResult := BoolToStr(false);
1021
1022 assertEqualsString('testBoolToStr_false', 'False', tmpResult);
1023 END;
1024
1025 // ----------------------------------------------------------
1026
1027
1028 FUNCTION getStringUtilsUnitTests : TList;
1029 BEGIN
1030 result := TList.Create;
1031
1032 result.add(@testTSerializableStringList_Construction);
1033 result.add(@testTSerializableStringList_Add);
1034 result.add(@testTSerializableStringList_Get_Empty);
1035 result.add(@testTSerializableStringList_Get);
1036 result.add(@testTSerializableStringList_getSerializedString_Empty);
1037 result.add(@testTSerializableStringList_getSerializedString);
1038 result.add(@testTSerializableStringList_getSerializedString);
1039 result.add(@testTSerializableStringList_getSerializedString_WithBlanks);
1040 result.add(@testTSerializableStringList_getSerializedString_Escaping);
1041 result.add(@testTSerializableStringList_readValuesFromSerializedString);
1042 result.add(@testTSerializableStringList_readValuesFromSerializedString_quoted);
1043 result.add(@testTSerializableStringList_readValuesFromSerializedString_empty);
1044 result.add(@testTSerializableStringList_readValuesFromSerializedString_firstempty);
1045 result.add(@testTSerializableStringList_readValuesFromSerializedString_2);
1046
1047 result.add(@testEscapeAllCharsBy);
1048 result.add(@testEscapeAllCharsBy_Empty);
1049 result.add(@testEscapeAllCharsBy_EmptyChars);
1050 result.add(@testEscapeAllCharsBy_EscapeEscape);
1051
1052 result.add(@testStrExtractStrings_EmptyReceiver);
1053 result.add(@testStrExtractStrings_OnlyOnePart);
1054 result.add(@testStrExtractStrings_ManyParts);
1055 result.add(@testStrExtractStrings_StartWithDelimiter);
1056 result.add(@testStrExtractStrings_EndWithDelimiter);
1057 result.add(@testStrExtractStrings_EmptyPartInside);
1058 result.add(@testStrExtractStrings_NoDelimiter);
1059 result.add(@testStrExtractStrings_EscapedDelimiter);
1060 result.add(@testStrExtractStrings_EscapedEscapeChar);
1061
1062 result.add(@testStrExtractStringsIgnoreEmpty_EmptyReceiver);
1063 result.add(@testStrExtractStringsIgnoreEmpty_OnlyOnePart);
1064 result.add(@testStrExtractStringsIgnoreEmpty_ManyParts);
1065 result.add(@testStrExtractStringsIgnoreEmpty_StartWithDelimiter);
1066 result.add(@testStrExtractStringsIgnoreEmpty_EndWithDelimiter);
1067 result.add(@testStrExtractStringsIgnoreEmpty_EmptyPartInside);
1068 result.add(@testStrExtractStringsIgnoreEmpty_NoDelimiter);
1069 result.add(@testStrExtractStringsIgnoreEmpty_EscapedDelimiter);
1070 result.add(@testStrExtractStringsIgnoreEmpty_EscapedEscapeChar);
1071
1072 result.add(@testTrimLeftChars_Empty);
1073 result.add(@testTrimLeftChars_RemoveAll);
1074 result.add(@testTrimLeftChars_OneLeft);
1075 result.add(@testTrimLeftChars_LeftOnly);
1076 result.add(@testTrimLeftChars_CharsInside);
1077 result.add(@testTrimLeftChars_Nothing);
1078
1079 result.add(@testTrimRightChars_Empty);
1080 result.add(@testTrimRightChars_RemoveAll);
1081 result.add(@testTrimRightChars_OneLeft);
1082 result.add(@testTrimRightChars_RightOnly);
1083 result.add(@testTrimRightChars_CharsInside);
1084 result.add(@testTrimRightChars_Nothing);
1085
1086 result.add(@testTrimChars_Empty);
1087 result.add(@testTrimChars_RemoveAll);
1088 result.add(@testTrimChars_OneLeftFromLeft);
1089 result.add(@testTrimChars_OneLeftFromRight);
1090 result.add(@testTrimChars_LeftOnly);
1091 result.add(@testTrimChars_RightOnly);
1092 result.add(@testTrimChars_CharsInside);
1093 result.add(@testTrimChars_Nothing);
1094
1095 result.add(@testTrim);
1096
1097 result.add(@testStrLeft_Empty);
1098 result.add(@testStrLeft_Nothing);
1099 result.add(@testStrLeft_WholeString);
1100 result.add(@testStrLeft_ToManyRequested);
1101 result.add(@testStrLeft_Part);
1102
1103 result.add(@testStrEndsWith_BothEmpty);
1104 result.add(@testStrEndsWith_StringEmpty);
1105 result.add(@testStrEndsWith_MatchEmpty);
1106 result.add(@testStrEndsWith_StringToShort);
1107 result.add(@testStrEndsWith_StringEqualLength);
1108 result.add(@testStrEndsWith_StringEqualLengthMatch);
1109 result.add(@testStrEndsWith_StringMatch);
1110 result.add(@testStrEndsWith_StringMatchCaseSensitive);
1111
1112 result.add(@testStrEndsWithIgnoringCase_BothEmpty);
1113 result.add(@testStrEndsWithIgnoringCase_StringEmpty);
1114 result.add(@testStrEndsWithIgnoringCase_MatchEmpty);
1115 result.add(@testStrEndsWithIgnoringCase_StringToShort);
1116 result.add(@testStrEndsWithIgnoringCase_StringEqualLength);
1117 result.add(@testStrEndsWithIgnoringCase_StringEqualLengthMatch);
1118 result.add(@testStrEndsWithIgnoringCase_StringMatch);
1119 result.add(@testStrEndsWithIgnoringCase_StringMatchCaseInSensitive);
1120
1121 result.add(@testLongWordToStr_Zero);
1122 result.add(@testLongWordToStr_Four);
1123 result.add(@testLongWordToStr_Max);
1124
1125 result.add(@testBoolToStr_true);
1126 result.add(@testBoolToStr_false);
1127 END;
1128
1129END.
Note: See TracBrowser for help on using the repository browser.