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

Last change on this file since 104 was 102, checked in by RBRi, 19 years ago

improved StringUtilsUnit
  • Property svn:eol-style set to native
File size: 38.4 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
817 PROCEDURE testStrLeftWithout_Empty;
818 VAR
819 tmpResult : String;
820 BEGIN
821 tmpResult := StrLeftWithout('', 4);
822
823 assertEqualsString('testStrLeftWithout_Empty', '', tmpResult);
824 END;
825
826
827 PROCEDURE testStrLeftWithout_ToBig;
828 VAR
829 tmpResult : String;
830 BEGIN
831 tmpResult := StrLeftWithout('ab', 4);
832
833 assertEqualsString('testStrLeftWithout_ToBig', '', tmpResult);
834 END;
835
836
837 PROCEDURE testStrLeftWithout_Negative;
838 VAR
839 tmpResult : String;
840 BEGIN
841 tmpResult := StrLeftWithout('ab', -1);
842
843 assertEqualsString('testStrLeftWithout_Negative', 'ab', tmpResult);
844 END;
845
846
847 PROCEDURE testStrLeftWithout_All;
848 VAR
849 tmpResult : String;
850 BEGIN
851 tmpResult := StrLeftWithout('abdefg', 6);
852
853 assertEqualsString('testStrLeftWithout_All', '', tmpResult);
854 END;
855
856
857 PROCEDURE testStrLeftWithout;
858 VAR
859 tmpResult : String;
860 BEGIN
861 tmpResult := StrLeftWithout('abdefg', 3);
862
863 assertEqualsString('testStrLeftWithout', 'abd', tmpResult);
864 END;
865
866
867 // -------------------------------------------------------------------
868
869
870 PROCEDURE testStrLeftUntil_Empty;
871 VAR
872 tmpResult : String;
873 BEGIN
874 tmpResult := StrLeftUntil('', ['b', 'x']);
875
876 assertEqualsString('testStrLeftUntil_Empty', '', tmpResult);
877 END;
878
879
880 PROCEDURE testStrLeftUntil_Empty_EmptyDelimiterSet;
881 VAR
882 tmpResult : String;
883 BEGIN
884 tmpResult := StrLeftUntil('', []);
885
886 assertEqualsString('testStrLeftUntil_Empty_EmptyDelimiterSet', '', tmpResult);
887 END;
888
889
890 PROCEDURE testStrLeftUntil_EmptyDelimiterSet;
891 VAR
892 tmpResult : String;
893 BEGIN
894 tmpResult := StrLeftUntil('abc', []);
895
896 assertEqualsString('testStrLeftUntil_EmptyDelimiterSet', 'abc', tmpResult);
897 END;
898
899
900 PROCEDURE testStrLeftUntil_FirstIsDelimiter;
901 VAR
902 tmpResult : String;
903 BEGIN
904 tmpResult := StrLeftUntil('abc', ['a']);
905
906 assertEqualsString('testStrLeftUntil_FirstIsDelimiter', '', tmpResult);
907 END;
908
909
910 PROCEDURE testStrLeftUntil_LastIsDelimiter;
911 VAR
912 tmpResult : String;
913 BEGIN
914 tmpResult := StrLeftUntil('abc', ['c']);
915
916 assertEqualsString('testStrLeftUntil_LastIsDelimiter', 'ab', tmpResult);
917 END;
918
919
920 PROCEDURE testStrLeftUntil_UnusedDelimiter;
921 VAR
922 tmpResult : String;
923 BEGIN
924 tmpResult := StrLeftUntil('abc', ['x']);
925
926 assertEqualsString('testStrLeftUntil_UnusedDelimiter', 'abc', tmpResult);
927 END;
928
929
930 PROCEDURE testStrLeftUntil;
931 VAR
932 tmpResult : String;
933 BEGIN
934 tmpResult := StrLeftUntil('abcx yz do', ['d', ' ']);
935
936 assertEqualsString('testStrLeftUntil', 'abcx', tmpResult);
937 END;
938
939
940 // -------------------------------------------------------------------
941
942
943 PROCEDURE testStrStartsWith_BothEmpty;
944 VAR
945 tmpResult : Boolean;
946 BEGIN
947 tmpResult := StrStartsWith('', '');
948
949 assertTrue('testStrStartsWith_BothEmpty', tmpResult);
950 END;
951
952
953 PROCEDURE testStrStartsWith_StringEmpty;
954 VAR
955 tmpResult : Boolean;
956 BEGIN
957 tmpResult := StrStartsWith('', 'end');
958
959 assertFalse('testStrStartsWith_StringEmpty', tmpResult);
960 END;
961
962
963 PROCEDURE testStrStartsWith_MatchEmpty;
964 VAR
965 tmpResult : Boolean;
966 BEGIN
967 tmpResult := StrStartsWith('test', '');
968
969 assertTrue('testStrStartsWith_MatchEmpty', tmpResult);
970 END;
971
972
973 PROCEDURE testStrStartsWith_StringToShort;
974 VAR
975 tmpResult : Boolean;
976 BEGIN
977 tmpResult := StrStartsWith('test', 'test1');
978
979 assertFalse('testStrStartsWith_StringToShort', tmpResult);
980 END;
981
982
983 PROCEDURE testStrStartsWith_StringEqualLength;
984 VAR
985 tmpResult : Boolean;
986 BEGIN
987 tmpResult := StrStartsWith('test', 'best');
988
989 assertFalse('testStrStartsWith_StringEqualLength', tmpResult);
990 END;
991
992
993 PROCEDURE testStrStartsWith_StringEqualLengthMatch;
994 VAR
995 tmpResult : Boolean;
996 BEGIN
997 tmpResult := StrStartsWith('test', 'test');
998
999 assertTrue('testStrStartsWith_StringEqualLengthMatch', tmpResult);
1000 END;
1001
1002
1003 PROCEDURE testStrStartsWith_StringMatch;
1004 VAR
1005 tmpResult : Boolean;
1006 BEGIN
1007 tmpResult := StrStartsWith('this is a simple test', 'this');
1008
1009 assertTrue('testStrStartsWith_StringMatch', tmpResult);
1010 END;
1011
1012
1013 PROCEDURE testStrStartsWith_StringMatchCaseSensitive;
1014 VAR
1015 tmpResult : Boolean;
1016 BEGIN
1017 tmpResult := StrStartsWith('This is a simple test', 'tHis');
1018
1019 assertFalse('testStrStartsWith_StringMatchCaseSensitive', tmpResult);
1020 END;
1021
1022
1023 // -------------------------------------------------------------------
1024
1025
1026 PROCEDURE testStrStartsWithIgnoringCase_BothEmpty;
1027 VAR
1028 tmpResult : Boolean;
1029 BEGIN
1030 tmpResult := StrStartsWithIgnoringCase('', '');
1031
1032 assertTrue('testStrStartsWithIgnoringCase_BothEmpty', tmpResult);
1033 END;
1034
1035
1036 PROCEDURE testStrStartsWithIgnoringCase_StringEmpty;
1037 VAR
1038 tmpResult : Boolean;
1039 BEGIN
1040 tmpResult := StrStartsWithIgnoringCase('', 'end');
1041
1042 assertFalse('testStrStartsWithIgnoringCase_StringEmpty', tmpResult);
1043 END;
1044
1045
1046 PROCEDURE testStrStartsWithIgnoringCase_MatchEmpty;
1047 VAR
1048 tmpResult : Boolean;
1049 BEGIN
1050 tmpResult := StrStartsWithIgnoringCase('test', '');
1051
1052 assertTrue('testStrStartsWithIgnoringCase_MatchEmpty', tmpResult);
1053 END;
1054
1055
1056 PROCEDURE testStrStartsWithIgnoringCase_StringToShort;
1057 VAR
1058 tmpResult : Boolean;
1059 BEGIN
1060 tmpResult := StrStartsWithIgnoringCase('test', 'test1');
1061
1062 assertFalse('testStrStartsWithIgnoringCase_StringToShort', tmpResult);
1063 END;
1064
1065
1066 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLength;
1067 VAR
1068 tmpResult : Boolean;
1069 BEGIN
1070 tmpResult := StrStartsWithIgnoringCase('test', 'best');
1071
1072 assertFalse('testStrStartsWithIgnoringCase_StringEqualLength', tmpResult);
1073 END;
1074
1075
1076 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLengthMatch;
1077 VAR
1078 tmpResult : Boolean;
1079 BEGIN
1080 tmpResult := StrStartsWithIgnoringCase('test', 'test');
1081
1082 assertTrue('testStrStartsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1083 END;
1084
1085
1086 PROCEDURE testStrStartsWithIgnoringCase_StringMatch;
1087 VAR
1088 tmpResult : Boolean;
1089 BEGIN
1090 tmpResult := StrStartsWithIgnoringCase('This is a simple test', 'This');
1091
1092 assertTrue('testStrStartsWithIgnoringCase_StringMatch', tmpResult);
1093 END;
1094
1095
1096 PROCEDURE testStrStartsWithIgnoringCase_StringMatchCaseInSensitive;
1097 VAR
1098 tmpResult : Boolean;
1099 BEGIN
1100 tmpResult := StrStartsWithIgnoringCase('ThiS is a simple test', 'THis');
1101
1102 assertTrue('testStrStartsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1103 END;
1104
1105
1106 // -------------------------------------------------------------------
1107
1108
1109 PROCEDURE testStrEndsWith_BothEmpty;
1110 VAR
1111 tmpResult : Boolean;
1112 BEGIN
1113 tmpResult := StrEndsWith('', '');
1114
1115 assertTrue('testStrEndsWith_BothEmpty', tmpResult);
1116 END;
1117
1118
1119 PROCEDURE testStrEndsWith_StringEmpty;
1120 VAR
1121 tmpResult : Boolean;
1122 BEGIN
1123 tmpResult := StrEndsWith('', 'end');
1124
1125 assertFalse('testStrEndsWith_StringEmpty', tmpResult);
1126 END;
1127
1128
1129 PROCEDURE testStrEndsWith_MatchEmpty;
1130 VAR
1131 tmpResult : Boolean;
1132 BEGIN
1133 tmpResult := StrEndsWith('test', '');
1134
1135 assertTrue('testStrEndsWith_MatchEmpty', tmpResult);
1136 END;
1137
1138
1139 PROCEDURE testStrEndsWith_StringToShort;
1140 VAR
1141 tmpResult : Boolean;
1142 BEGIN
1143 tmpResult := StrEndsWith('test', 'test1');
1144
1145 assertFalse('testStrEndsWith_StringToShort', tmpResult);
1146 END;
1147
1148
1149 PROCEDURE testStrEndsWith_StringEqualLength;
1150 VAR
1151 tmpResult : Boolean;
1152 BEGIN
1153 tmpResult := StrEndsWith('test', 'best');
1154
1155 assertFalse('testStrEndsWith_StringEqualLength', tmpResult);
1156 END;
1157
1158
1159 PROCEDURE testStrEndsWith_StringEqualLengthMatch;
1160 VAR
1161 tmpResult : Boolean;
1162 BEGIN
1163 tmpResult := StrEndsWith('test', 'test');
1164
1165 assertTrue('testStrEndsWith_StringEqualLengthMatch', tmpResult);
1166 END;
1167
1168
1169 PROCEDURE testStrEndsWith_StringMatch;
1170 VAR
1171 tmpResult : Boolean;
1172 BEGIN
1173 tmpResult := StrEndsWith('a simple test', 'test');
1174
1175 assertTrue('testStrEndsWith_StringMatch', tmpResult);
1176 END;
1177
1178
1179 PROCEDURE testStrEndsWith_StringMatchCaseSensitive;
1180 VAR
1181 tmpResult : Boolean;
1182 BEGIN
1183 tmpResult := StrEndsWith('a simple tEst', 'test');
1184
1185 assertFalse('testStrEndsWith_StringMatchCaseSensitive', tmpResult);
1186 END;
1187
1188
1189 PROCEDURE testStrEndsWithIgnoringCase_BothEmpty;
1190 VAR
1191 tmpResult : Boolean;
1192 BEGIN
1193 tmpResult := StrEndsWithIgnoringCase('', '');
1194
1195 assertTrue('testStrEndsWithIgnoringCase_BothEmpty', tmpResult);
1196 END;
1197
1198
1199 PROCEDURE testStrEndsWithIgnoringCase_StringEmpty;
1200 VAR
1201 tmpResult : Boolean;
1202 BEGIN
1203 tmpResult := StrEndsWithIgnoringCase('', 'end');
1204
1205 assertFalse('testStrEndsWithIgnoringCase_StringEmpty', tmpResult);
1206 END;
1207
1208
1209 PROCEDURE testStrEndsWithIgnoringCase_MatchEmpty;
1210 VAR
1211 tmpResult : Boolean;
1212 BEGIN
1213 tmpResult := StrEndsWithIgnoringCase('test', '');
1214
1215 assertTrue('testStrEndsWithIgnoringCase_MatchEmpty', tmpResult);
1216 END;
1217
1218
1219 PROCEDURE testStrEndsWithIgnoringCase_StringToShort;
1220 VAR
1221 tmpResult : Boolean;
1222 BEGIN
1223 tmpResult := StrEndsWithIgnoringCase('test', 'test1');
1224
1225 assertFalse('testStrEndsWithIgnoringCase_StringToShort', tmpResult);
1226 END;
1227
1228
1229 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLength;
1230 VAR
1231 tmpResult : Boolean;
1232 BEGIN
1233 tmpResult := StrEndsWithIgnoringCase('test', 'best');
1234
1235 assertFalse('testStrEndsWithIgnoringCase_StringEqualLength', tmpResult);
1236 END;
1237
1238
1239 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLengthMatch;
1240 VAR
1241 tmpResult : Boolean;
1242 BEGIN
1243 tmpResult := StrEndsWithIgnoringCase('test', 'test');
1244
1245 assertTrue('testStrEndsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1246 END;
1247
1248
1249 PROCEDURE testStrEndsWithIgnoringCase_StringMatch;
1250 VAR
1251 tmpResult : Boolean;
1252 BEGIN
1253 tmpResult := StrEndsWithIgnoringCase('a simple test', 'test');
1254
1255 assertTrue('testStrEndsWithIgnoringCase_StringMatch', tmpResult);
1256 END;
1257
1258
1259 PROCEDURE testStrEndsWithIgnoringCase_StringMatchCaseInSensitive;
1260 VAR
1261 tmpResult : Boolean;
1262 BEGIN
1263 tmpResult := StrEndsWithIgnoringCase('a simple tEst', 'test');
1264
1265 assertTrue('testStrEndsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1266 END;
1267
1268
1269 PROCEDURE testLongWordToStr_Zero;
1270 VAR
1271 tmpResult : String;
1272 BEGIN
1273 tmpResult := LongWordToStr(0);
1274
1275 assertEqualsString('testLongWordToStr_Zero', '0', tmpResult);
1276 END;
1277
1278
1279 PROCEDURE testLongWordToStr_Four;
1280 VAR
1281 tmpResult : String;
1282 BEGIN
1283 tmpResult := LongWordToStr(4);
1284
1285 assertEqualsString('testLongWordToStr_Four', '4', tmpResult);
1286 END;
1287
1288 PROCEDURE testLongWordToStr_Max;
1289 VAR
1290 tmpResult : String;
1291 BEGIN
1292 tmpResult := LongWordToStr(4294967295);
1293
1294 assertEqualsString('testLongWordToStr_Max', '4294967295', tmpResult);
1295 END;
1296
1297
1298
1299 PROCEDURE testBoolToStr_true;
1300 VAR
1301 tmpResult : String;
1302 BEGIN
1303 tmpResult := BoolToStr(true);
1304
1305 assertEqualsString('testBoolToStr_true', 'True', tmpResult);
1306 END;
1307
1308
1309 PROCEDURE testBoolToStr_false;
1310 VAR
1311 tmpResult : String;
1312 BEGIN
1313 tmpResult := BoolToStr(false);
1314
1315 assertEqualsString('testBoolToStr_false', 'False', tmpResult);
1316 END;
1317
1318 // ----------------------------------------------------------
1319
1320
1321 PROCEDURE testStrInDoubleQuotes_Empty;
1322 VAR
1323 tmpResult : String;
1324 BEGIN
1325 tmpResult := StrInDoubleQuotes('');
1326
1327 assertEqualsString('testStrInDoubleQuotes_Empty', '""', tmpResult);
1328 END;
1329
1330
1331 PROCEDURE testStrInDoubleQuotes;
1332 VAR
1333 tmpResult : String;
1334 BEGIN
1335 tmpResult := StrInDoubleQuotes('abc');
1336
1337 assertEqualsString('testStrInDoubleQuotes', '"abc"', tmpResult);
1338 END;
1339
1340
1341 // ----------------------------------------------------------
1342
1343
1344 FUNCTION getStringUtilsUnitTests : TList;
1345 BEGIN
1346 result := TList.Create;
1347
1348 result.add(@testTSerializableStringList_Construction);
1349 result.add(@testTSerializableStringList_Add);
1350 result.add(@testTSerializableStringList_Get_Empty);
1351 result.add(@testTSerializableStringList_Get);
1352 result.add(@testTSerializableStringList_getSerializedString_Empty);
1353 result.add(@testTSerializableStringList_getSerializedString);
1354 result.add(@testTSerializableStringList_getSerializedString);
1355 result.add(@testTSerializableStringList_getSerializedString_WithBlanks);
1356 result.add(@testTSerializableStringList_getSerializedString_Escaping);
1357 result.add(@testTSerializableStringList_readValuesFromSerializedString);
1358 result.add(@testTSerializableStringList_readValuesFromSerializedString_quoted);
1359 result.add(@testTSerializableStringList_readValuesFromSerializedString_empty);
1360 result.add(@testTSerializableStringList_readValuesFromSerializedString_firstempty);
1361 result.add(@testTSerializableStringList_readValuesFromSerializedString_2);
1362
1363 result.add(@testEscapeAllCharsBy);
1364 result.add(@testEscapeAllCharsBy_Empty);
1365 result.add(@testEscapeAllCharsBy_EmptyChars);
1366 result.add(@testEscapeAllCharsBy_EscapeEscape);
1367
1368 result.add(@testStrExtractStrings_EmptyReceiver);
1369 result.add(@testStrExtractStrings_OnlyOnePart);
1370 result.add(@testStrExtractStrings_ManyParts);
1371 result.add(@testStrExtractStrings_StartWithDelimiter);
1372 result.add(@testStrExtractStrings_EndWithDelimiter);
1373 result.add(@testStrExtractStrings_EmptyPartInside);
1374 result.add(@testStrExtractStrings_NoDelimiter);
1375 result.add(@testStrExtractStrings_EscapedDelimiter);
1376 result.add(@testStrExtractStrings_EscapedEscapeChar);
1377
1378 result.add(@testStrExtractStringsIgnoreEmpty_EmptyReceiver);
1379 result.add(@testStrExtractStringsIgnoreEmpty_OnlyOnePart);
1380 result.add(@testStrExtractStringsIgnoreEmpty_ManyParts);
1381 result.add(@testStrExtractStringsIgnoreEmpty_StartWithDelimiter);
1382 result.add(@testStrExtractStringsIgnoreEmpty_EndWithDelimiter);
1383 result.add(@testStrExtractStringsIgnoreEmpty_EmptyPartInside);
1384 result.add(@testStrExtractStringsIgnoreEmpty_NoDelimiter);
1385 result.add(@testStrExtractStringsIgnoreEmpty_EscapedDelimiter);
1386 result.add(@testStrExtractStringsIgnoreEmpty_EscapedEscapeChar);
1387
1388 result.add(@testTrimLeftChars_Empty);
1389 result.add(@testTrimLeftChars_RemoveAll);
1390 result.add(@testTrimLeftChars_OneLeft);
1391 result.add(@testTrimLeftChars_LeftOnly);
1392 result.add(@testTrimLeftChars_CharsInside);
1393 result.add(@testTrimLeftChars_Nothing);
1394
1395 result.add(@testTrimRightChars_Empty);
1396 result.add(@testTrimRightChars_RemoveAll);
1397 result.add(@testTrimRightChars_OneLeft);
1398 result.add(@testTrimRightChars_RightOnly);
1399 result.add(@testTrimRightChars_CharsInside);
1400 result.add(@testTrimRightChars_Nothing);
1401
1402 result.add(@testTrimChars_Empty);
1403 result.add(@testTrimChars_RemoveAll);
1404 result.add(@testTrimChars_OneLeftFromLeft);
1405 result.add(@testTrimChars_OneLeftFromRight);
1406 result.add(@testTrimChars_LeftOnly);
1407 result.add(@testTrimChars_RightOnly);
1408 result.add(@testTrimChars_CharsInside);
1409 result.add(@testTrimChars_Nothing);
1410
1411 result.add(@testTrim);
1412
1413 result.add(@testStrLeft_Empty);
1414 result.add(@testStrLeft_Nothing);
1415 result.add(@testStrLeft_WholeString);
1416 result.add(@testStrLeft_ToManyRequested);
1417 result.add(@testStrLeft_Part);
1418
1419 result.add(@testStrLeftWithout_Empty);
1420 result.add(@testStrLeftWithout_ToBig);
1421 result.add(@testStrLeftWithout_Negative);
1422 result.add(@testStrLeftWithout_All);
1423 result.add(@testStrLeftWithout);
1424
1425 result.add(@testStrLeftUntil_Empty);
1426 result.add(@testStrLeftUntil_Empty_EmptyDelimiterSet);
1427 result.add(@testStrLeftUntil_EmptyDelimiterSet);
1428 result.add(@testStrLeftUntil_FirstIsDelimiter);
1429 result.add(@testStrLeftUntil_LastIsDelimiter);
1430 result.add(@testStrLeftUntil_UnusedDelimiter);
1431 result.add(@testStrLeftUntil);
1432
1433 result.add(@testStrStartsWith_BothEmpty);
1434 result.add(@testStrStartsWith_StringEmpty);
1435 result.add(@testStrStartsWith_MatchEmpty);
1436 result.add(@testStrStartsWith_StringToShort);
1437 result.add(@testStrStartsWith_StringEqualLength);
1438 result.add(@testStrStartsWith_StringEqualLengthMatch);
1439 result.add(@testStrStartsWith_StringMatch);
1440 result.add(@testStrStartsWith_StringMatchCaseSensitive);
1441
1442 result.add(@testStrStartsWithIgnoringCase_BothEmpty);
1443 result.add(@testStrStartsWithIgnoringCase_StringEmpty);
1444 result.add(@testStrStartsWithIgnoringCase_MatchEmpty);
1445 result.add(@testStrStartsWithIgnoringCase_StringToShort);
1446 result.add(@testStrStartsWithIgnoringCase_StringEqualLength);
1447 result.add(@testStrStartsWithIgnoringCase_StringEqualLengthMatch);
1448 result.add(@testStrStartsWithIgnoringCase_StringMatch);
1449 result.add(@testStrStartsWithIgnoringCase_StringMatchCaseInSensitive);
1450
1451 result.add(@testStrEndsWith_BothEmpty);
1452 result.add(@testStrEndsWith_StringEmpty);
1453 result.add(@testStrEndsWith_MatchEmpty);
1454 result.add(@testStrEndsWith_StringToShort);
1455 result.add(@testStrEndsWith_StringEqualLength);
1456 result.add(@testStrEndsWith_StringEqualLengthMatch);
1457 result.add(@testStrEndsWith_StringMatch);
1458 result.add(@testStrEndsWith_StringMatchCaseSensitive);
1459
1460 result.add(@testStrEndsWithIgnoringCase_BothEmpty);
1461 result.add(@testStrEndsWithIgnoringCase_StringEmpty);
1462 result.add(@testStrEndsWithIgnoringCase_MatchEmpty);
1463 result.add(@testStrEndsWithIgnoringCase_StringToShort);
1464 result.add(@testStrEndsWithIgnoringCase_StringEqualLength);
1465 result.add(@testStrEndsWithIgnoringCase_StringEqualLengthMatch);
1466 result.add(@testStrEndsWithIgnoringCase_StringMatch);
1467 result.add(@testStrEndsWithIgnoringCase_StringMatchCaseInSensitive);
1468
1469 result.add(@testLongWordToStr_Zero);
1470 result.add(@testLongWordToStr_Four);
1471 result.add(@testLongWordToStr_Max);
1472
1473 result.add(@testBoolToStr_true);
1474 result.add(@testBoolToStr_false);
1475
1476 result.add(@testStrInDoubleQuotes_Empty);
1477 result.add(@testStrInDoubleQuotes);
1478 END;
1479
1480END.
Note: See TracBrowser for help on using the repository browser.