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

Last change on this file since 105 was 105, checked in by RBRi, 18 years ago

%more stringutils refactoring
  • Property svn:eol-style set to native
File size: 40.8 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 PROCEDURE testStrExtractStrings_DelimiterSameAsEscapeChar;
413 VAR
414 tmpResult : TStringList;
415 BEGIN
416 tmpResult := TStringList.Create;
417 StrExtractStrings(tmpResult, 'a;b;;cd;;;', [';'], ';');
418
419 assertEqualsInt('testStrExtractStrings_EscapedEscapeChar', 3, tmpResult.count);
420 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'a', tmpResult[0]);
421 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'b;cd;', tmpResult[1]);
422 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', '', tmpResult[2]);
423
424 tmpResult.Destroy;
425 END;
426
427 // ------------------------------------------------------
428
429
430 PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyReceiver;
431 VAR
432 tmpResult : TStringList;
433 BEGIN
434 tmpResult := TStringList.Create;
435 StrExtractStringsIgnoreEmpty(tmpResult, '', ['x'], '\');
436
437 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyReceiver', 0, tmpResult.count);
438 tmpResult.Destroy;
439 END;
440
441
442 PROCEDURE testStrExtractStringsIgnoreEmpty_OnlyOnePart;
443 VAR
444 tmpResult : TStringList;
445 BEGIN
446 tmpResult := TStringList.Create;
447 StrExtractStringsIgnoreEmpty(tmpResult, 'abcd', ['x'], '\');
448
449 assertEqualsInt('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 1, tmpResult.count);
450 assertEqualsString('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 'abcd', tmpResult[0]);
451
452 tmpResult.Destroy;
453 END;
454
455
456 PROCEDURE testStrExtractStringsIgnoreEmpty_ManyParts;
457 VAR
458 tmpResult : TStringList;
459 BEGIN
460 tmpResult := TStringList.Create;
461 StrExtractStringsIgnoreEmpty(tmpResult, 'abxcd', ['x'], '\');
462
463 assertEqualsInt('testStrExtractStringsIgnoreEmpty_ManyParts', 2, tmpResult.count);
464 assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'ab', tmpResult[0]);
465 assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'cd', tmpResult[1]);
466
467 tmpResult.Destroy;
468 END;
469
470
471 PROCEDURE testStrExtractStringsIgnoreEmpty_StartWithDelimiter;
472 VAR
473 tmpResult : TStringList;
474 BEGIN
475 tmpResult := TStringList.Create;
476 StrExtractStringsIgnoreEmpty(tmpResult, 'xab', ['x'], '\');
477
478 assertEqualsInt('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 1, tmpResult.count);
479 assertEqualsString('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 'ab', tmpResult[0]);
480
481 tmpResult.Destroy;
482 END;
483
484
485 PROCEDURE testStrExtractStringsIgnoreEmpty_EndWithDelimiter;
486 VAR
487 tmpResult : TStringList;
488 BEGIN
489 tmpResult := TStringList.Create;
490 StrExtractStringsIgnoreEmpty(tmpResult, 'abx', ['x'], '\');
491
492 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 1, tmpResult.count);
493 assertEqualsString('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 'ab', tmpResult[0]);
494
495 tmpResult.Destroy;
496 END;
497
498
499 PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyPartInside;
500 VAR
501 tmpResult : TStringList;
502 BEGIN
503 tmpResult := TStringList.Create;
504 StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', ['x'], '\');
505
506 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 2, tmpResult.count);
507 assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'a', tmpResult[0]);
508 assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'b', tmpResult[1]);
509
510 tmpResult.Destroy;
511 END;
512
513
514 PROCEDURE testStrExtractStringsIgnoreEmpty_NoDelimiter;
515 VAR
516 tmpResult : TStringList;
517 BEGIN
518 tmpResult := TStringList.Create;
519 StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', [], '\');
520
521 assertEqualsInt('testStrExtractStringsIgnoreEmpty_NoDelimiter', 1, tmpResult.count);
522 assertEqualsString('testStrExtractStringsIgnoreEmpty_NoDelimiter', 'axxb', tmpResult[0]);
523
524 tmpResult.Destroy;
525 END;
526
527
528 PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedDelimiter;
529 VAR
530 tmpResult : TStringList;
531 BEGIN
532 tmpResult := TStringList.Create;
533 StrExtractStringsIgnoreEmpty(tmpResult, 'a\xb', ['x'], '\');
534
535 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 1, tmpResult.count);
536 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 'axb', tmpResult[0]);
537
538 tmpResult.Destroy;
539 END;
540
541 PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedEscapeChar;
542 VAR
543 tmpResult : TStringList;
544 BEGIN
545 tmpResult := TStringList.Create;
546 StrExtractStringsIgnoreEmpty(tmpResult, 'a\\xb', ['x'], '\');
547
548 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 2, tmpResult.count);
549 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'a\', tmpResult[0]);
550 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'b', tmpResult[1]);
551
552 tmpResult.Destroy;
553 END;
554
555
556 // -------------------------------------------------------------------
557
558
559 PROCEDURE testTrimLeftChars_Empty;
560 VAR
561 tmpResult : String;
562 BEGIN
563 tmpResult := StrTrimLeftChars('', ['b', 'x']);
564
565 assertEqualsString('testTrimLeftChars_Empty', '', tmpResult);
566 END;
567
568
569 PROCEDURE testTrimLeftChars_RemoveAll;
570 VAR
571 tmpResult : String;
572 BEGIN
573 tmpResult := StrTrimLeftChars('bxxxbx', ['b', 'x']);
574
575 assertEqualsString('testTrimLeftChars_RemoveAll', '', tmpResult);
576 END;
577
578
579 PROCEDURE testTrimLeftChars_OneLeft;
580 VAR
581 tmpResult : String;
582 BEGIN
583 tmpResult := StrTrimLeftChars('bxy', ['b', 'x']);
584
585 assertEqualsString('testTrimLeftChars_OneLeft', 'y', tmpResult);
586 END;
587
588
589 PROCEDURE testTrimLeftChars_LeftOnly;
590 VAR
591 tmpResult : String;
592 BEGIN
593 tmpResult := StrTrimLeftChars('bxbxxay', ['b', 'x']);
594
595 assertEqualsString('testTrimLeftChars_LeftOnly', 'ay', tmpResult);
596 END;
597
598
599 PROCEDURE testTrimLeftChars_CharsInside;
600 VAR
601 tmpResult : String;
602 BEGIN
603 tmpResult := StrTrimLeftChars('bxabxvvx', ['b', 'x']);
604
605 assertEqualsString('testTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
606 END;
607
608
609 PROCEDURE testTrimLeftChars_Nothing;
610 VAR
611 tmpResult : String;
612 BEGIN
613 tmpResult := StrTrimLeftChars('acdef', ['b', 'x']);
614
615 assertEqualsString('testTrimLeftChars_Nothing', 'acdef', tmpResult);
616 END;
617
618
619 // -------------------------------------------------------------------
620
621
622 PROCEDURE testTrimRightChars_Empty;
623 VAR
624 tmpResult : String;
625 BEGIN
626 tmpResult := StrTrimRightChars('', ['b', 'x']);
627
628 assertEqualsString('testTrimRightChars_Empty', '', tmpResult);
629 END;
630
631
632 PROCEDURE testTrimRightChars_RemoveAll;
633 VAR
634 tmpResult : String;
635 BEGIN
636 tmpResult := StrTrimRightChars('bxxxbx', ['b', 'x']);
637
638 assertEqualsString('testTrimRightChars_RemoveAll', '', tmpResult);
639 END;
640
641
642 PROCEDURE testTrimRightChars_OneLeft;
643 VAR
644 tmpResult : String;
645 BEGIN
646 tmpResult := StrTrimRightChars('ybx', ['b', 'x']);
647
648 assertEqualsString('testTrimRightChars_OneLeft', 'y', tmpResult);
649 END;
650
651
652 PROCEDURE testTrimRightChars_RightOnly;
653 VAR
654 tmpResult : String;
655 BEGIN
656 tmpResult := StrTrimRightChars('aybxbxx', ['b', 'x']);
657
658 assertEqualsString('testTrimRightChars_RightOnly', 'ay', tmpResult);
659 END;
660
661
662 PROCEDURE testTrimRightChars_CharsInside;
663 VAR
664 tmpResult : String;
665 BEGIN
666 tmpResult := StrTrimRightChars('abxvvxb', ['b', 'x']);
667
668 assertEqualsString('testTrimRightChars_CharsInside', 'abxvv', tmpResult);
669 END;
670
671
672 PROCEDURE testTrimRightChars_Nothing;
673 VAR
674 tmpResult : String;
675 BEGIN
676 tmpResult := StrTrimRightChars('acdef', ['b', 'x']);
677
678 assertEqualsString('testTrimRightChars_Nothing', 'acdef', tmpResult);
679 END;
680
681
682 // -------------------------------------------------------------------
683
684 PROCEDURE testTrimChars_Empty;
685 VAR
686 tmpResult : String;
687 BEGIN
688 tmpResult := StrTrimChars('', ['b', 'x']);
689
690 assertEqualsString('testTrimChars_Empty', '', tmpResult);
691 END;
692
693
694 PROCEDURE testTrimChars_RemoveAll;
695 VAR
696 tmpResult : String;
697 BEGIN
698 tmpResult := StrTrimChars('bxxxbx', ['b', 'x']);
699
700 assertEqualsString('testTrimChars_RemoveAll', '', tmpResult);
701 END;
702
703
704 PROCEDURE testTrimChars_OneLeftFromLeft;
705 VAR
706 tmpResult : String;
707 BEGIN
708 tmpResult := StrTrimChars('bxa', ['b', 'x']);
709
710 assertEqualsString('testTrimChars_OneLeftFromLeft', 'a', tmpResult);
711 END;
712
713
714 PROCEDURE testTrimChars_OneLeftFromRight;
715 VAR
716 tmpResult : String;
717 BEGIN
718 tmpResult := StrTrimChars('abx', ['b', 'x']);
719
720 assertEqualsString('testTrimChars_OneLeftFromRight', 'a', tmpResult);
721 END;
722
723
724 PROCEDURE testTrimChars_LeftOnly;
725 VAR
726 tmpResult : String;
727 BEGIN
728 tmpResult := StrTrimChars('bxbxxay', ['b', 'x']);
729
730 assertEqualsString('testTrimChars_LeftOnly', 'ay', tmpResult);
731 END;
732
733
734 PROCEDURE testTrimChars_RightOnly;
735 VAR
736 tmpResult : String;
737 BEGIN
738 tmpResult := StrTrimChars('aybxbxx', ['b', 'x']);
739
740 assertEqualsString('testTrimChars_LeftOnly', 'ay', tmpResult);
741 END;
742
743
744 PROCEDURE testTrimChars_CharsInside;
745 VAR
746 tmpResult : String;
747 BEGIN
748 tmpResult := StrTrimChars('bxabxvvx', ['b', 'x']);
749
750 assertEqualsString('testTrimChars_CharsInside', 'abxvv', tmpResult);
751 END;
752
753
754 PROCEDURE testTrimChars_Nothing;
755 VAR
756 tmpResult : String;
757 BEGIN
758 tmpResult := StrTrimChars('acdef', ['b', 'x']);
759
760 assertEqualsString('testTrimChars_Nothing', 'acdef', tmpResult);
761 END;
762
763
764 // -------------------------------------------------------------------
765
766
767 PROCEDURE testTrim;
768 VAR
769 tmpResult : String;
770 BEGIN
771 tmpResult := StrTrim(' a bc ');
772
773 assertEqualsString('testTrim', 'a bc', tmpResult);
774 END;
775
776
777 // -------------------------------------------------------------------
778
779
780 PROCEDURE testStrLeft_Empty;
781 VAR
782 tmpResult : String;
783 BEGIN
784 tmpResult := StrLeft('', 1);
785
786 assertEqualsString('testStrLeft_Empty', '', tmpResult);
787 END;
788
789
790 PROCEDURE testStrLeft_Nothing;
791 VAR
792 tmpResult : String;
793 BEGIN
794 tmpResult := StrLeft('abc', 0);
795
796 assertEqualsString('testStrLeft_Nothing', '', tmpResult);
797 END;
798
799
800 PROCEDURE testStrLeft_WholeString;
801 VAR
802 tmpResult : String;
803 BEGIN
804 tmpResult := StrLeft('abc', 3);
805
806 assertEqualsString('testStrLeft_WholeString', 'abc', tmpResult);
807 END;
808
809 PROCEDURE testStrLeft_ToManyRequested;
810 VAR
811 tmpResult : String;
812 BEGIN
813 tmpResult := StrLeft('abc', 5);
814
815 assertEqualsString('testStrLeft_ToManyRequested', 'abc', tmpResult);
816 END;
817
818 PROCEDURE testStrLeft_Part;
819 VAR
820 tmpResult : String;
821 BEGIN
822 tmpResult := StrLeft('abcdef', 2);
823
824 assertEqualsString('testStrLeft_Part', 'ab', tmpResult);
825 END;
826
827
828 // -------------------------------------------------------------------
829
830
831 PROCEDURE testStrLeftWithout_Empty;
832 VAR
833 tmpResult : String;
834 BEGIN
835 tmpResult := StrLeftWithout('', 4);
836
837 assertEqualsString('testStrLeftWithout_Empty', '', tmpResult);
838 END;
839
840
841 PROCEDURE testStrLeftWithout_ToBig;
842 VAR
843 tmpResult : String;
844 BEGIN
845 tmpResult := StrLeftWithout('ab', 4);
846
847 assertEqualsString('testStrLeftWithout_ToBig', '', tmpResult);
848 END;
849
850
851 PROCEDURE testStrLeftWithout_Negative;
852 VAR
853 tmpResult : String;
854 BEGIN
855 tmpResult := StrLeftWithout('ab', -1);
856
857 assertEqualsString('testStrLeftWithout_Negative', 'ab', tmpResult);
858 END;
859
860
861 PROCEDURE testStrLeftWithout_All;
862 VAR
863 tmpResult : String;
864 BEGIN
865 tmpResult := StrLeftWithout('abdefg', 6);
866
867 assertEqualsString('testStrLeftWithout_All', '', tmpResult);
868 END;
869
870
871 PROCEDURE testStrLeftWithout;
872 VAR
873 tmpResult : String;
874 BEGIN
875 tmpResult := StrLeftWithout('abdefg', 3);
876
877 assertEqualsString('testStrLeftWithout', 'abd', tmpResult);
878 END;
879
880
881 // -------------------------------------------------------------------
882
883
884 PROCEDURE testStrLeftUntil_Empty;
885 VAR
886 tmpResult : String;
887 BEGIN
888 tmpResult := StrLeftUntil('', ['b', 'x']);
889
890 assertEqualsString('testStrLeftUntil_Empty', '', tmpResult);
891 END;
892
893
894 PROCEDURE testStrLeftUntil_Empty_EmptyDelimiterSet;
895 VAR
896 tmpResult : String;
897 BEGIN
898 tmpResult := StrLeftUntil('', []);
899
900 assertEqualsString('testStrLeftUntil_Empty_EmptyDelimiterSet', '', tmpResult);
901 END;
902
903
904 PROCEDURE testStrLeftUntil_EmptyDelimiterSet;
905 VAR
906 tmpResult : String;
907 BEGIN
908 tmpResult := StrLeftUntil('abc', []);
909
910 assertEqualsString('testStrLeftUntil_EmptyDelimiterSet', 'abc', tmpResult);
911 END;
912
913
914 PROCEDURE testStrLeftUntil_FirstIsDelimiter;
915 VAR
916 tmpResult : String;
917 BEGIN
918 tmpResult := StrLeftUntil('abc', ['a']);
919
920 assertEqualsString('testStrLeftUntil_FirstIsDelimiter', '', tmpResult);
921 END;
922
923
924 PROCEDURE testStrLeftUntil_LastIsDelimiter;
925 VAR
926 tmpResult : String;
927 BEGIN
928 tmpResult := StrLeftUntil('abc', ['c']);
929
930 assertEqualsString('testStrLeftUntil_LastIsDelimiter', 'ab', tmpResult);
931 END;
932
933
934 PROCEDURE testStrLeftUntil_UnusedDelimiter;
935 VAR
936 tmpResult : String;
937 BEGIN
938 tmpResult := StrLeftUntil('abc', ['x']);
939
940 assertEqualsString('testStrLeftUntil_UnusedDelimiter', 'abc', tmpResult);
941 END;
942
943
944 PROCEDURE testStrLeftUntil;
945 VAR
946 tmpResult : String;
947 BEGIN
948 tmpResult := StrLeftUntil('abcx yz do', ['d', ' ']);
949
950 assertEqualsString('testStrLeftUntil', 'abcx', tmpResult);
951 END;
952
953
954 // -------------------------------------------------------------------
955
956
957 PROCEDURE testStrStartsWith_BothEmpty;
958 VAR
959 tmpResult : Boolean;
960 BEGIN
961 tmpResult := StrStartsWith('', '');
962
963 assertTrue('testStrStartsWith_BothEmpty', tmpResult);
964 END;
965
966
967 PROCEDURE testStrStartsWith_StringEmpty;
968 VAR
969 tmpResult : Boolean;
970 BEGIN
971 tmpResult := StrStartsWith('', 'end');
972
973 assertFalse('testStrStartsWith_StringEmpty', tmpResult);
974 END;
975
976
977 PROCEDURE testStrStartsWith_MatchEmpty;
978 VAR
979 tmpResult : Boolean;
980 BEGIN
981 tmpResult := StrStartsWith('test', '');
982
983 assertTrue('testStrStartsWith_MatchEmpty', tmpResult);
984 END;
985
986
987 PROCEDURE testStrStartsWith_StringToShort;
988 VAR
989 tmpResult : Boolean;
990 BEGIN
991 tmpResult := StrStartsWith('test', 'test1');
992
993 assertFalse('testStrStartsWith_StringToShort', tmpResult);
994 END;
995
996
997 PROCEDURE testStrStartsWith_StringEqualLength;
998 VAR
999 tmpResult : Boolean;
1000 BEGIN
1001 tmpResult := StrStartsWith('test', 'best');
1002
1003 assertFalse('testStrStartsWith_StringEqualLength', tmpResult);
1004 END;
1005
1006
1007 PROCEDURE testStrStartsWith_StringEqualLengthMatch;
1008 VAR
1009 tmpResult : Boolean;
1010 BEGIN
1011 tmpResult := StrStartsWith('test', 'test');
1012
1013 assertTrue('testStrStartsWith_StringEqualLengthMatch', tmpResult);
1014 END;
1015
1016
1017 PROCEDURE testStrStartsWith_StringMatch;
1018 VAR
1019 tmpResult : Boolean;
1020 BEGIN
1021 tmpResult := StrStartsWith('this is a simple test', 'this');
1022
1023 assertTrue('testStrStartsWith_StringMatch', tmpResult);
1024 END;
1025
1026
1027 PROCEDURE testStrStartsWith_StringMatchCaseSensitive;
1028 VAR
1029 tmpResult : Boolean;
1030 BEGIN
1031 tmpResult := StrStartsWith('This is a simple test', 'tHis');
1032
1033 assertFalse('testStrStartsWith_StringMatchCaseSensitive', tmpResult);
1034 END;
1035
1036
1037 // -------------------------------------------------------------------
1038
1039
1040 PROCEDURE testStrStartsWithIgnoringCase_BothEmpty;
1041 VAR
1042 tmpResult : Boolean;
1043 BEGIN
1044 tmpResult := StrStartsWithIgnoringCase('', '');
1045
1046 assertTrue('testStrStartsWithIgnoringCase_BothEmpty', tmpResult);
1047 END;
1048
1049
1050 PROCEDURE testStrStartsWithIgnoringCase_StringEmpty;
1051 VAR
1052 tmpResult : Boolean;
1053 BEGIN
1054 tmpResult := StrStartsWithIgnoringCase('', 'end');
1055
1056 assertFalse('testStrStartsWithIgnoringCase_StringEmpty', tmpResult);
1057 END;
1058
1059
1060 PROCEDURE testStrStartsWithIgnoringCase_MatchEmpty;
1061 VAR
1062 tmpResult : Boolean;
1063 BEGIN
1064 tmpResult := StrStartsWithIgnoringCase('test', '');
1065
1066 assertTrue('testStrStartsWithIgnoringCase_MatchEmpty', tmpResult);
1067 END;
1068
1069
1070 PROCEDURE testStrStartsWithIgnoringCase_StringToShort;
1071 VAR
1072 tmpResult : Boolean;
1073 BEGIN
1074 tmpResult := StrStartsWithIgnoringCase('test', 'test1');
1075
1076 assertFalse('testStrStartsWithIgnoringCase_StringToShort', tmpResult);
1077 END;
1078
1079
1080 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLength;
1081 VAR
1082 tmpResult : Boolean;
1083 BEGIN
1084 tmpResult := StrStartsWithIgnoringCase('test', 'best');
1085
1086 assertFalse('testStrStartsWithIgnoringCase_StringEqualLength', tmpResult);
1087 END;
1088
1089
1090 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLengthMatch;
1091 VAR
1092 tmpResult : Boolean;
1093 BEGIN
1094 tmpResult := StrStartsWithIgnoringCase('test', 'test');
1095
1096 assertTrue('testStrStartsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1097 END;
1098
1099
1100 PROCEDURE testStrStartsWithIgnoringCase_StringMatch;
1101 VAR
1102 tmpResult : Boolean;
1103 BEGIN
1104 tmpResult := StrStartsWithIgnoringCase('This is a simple test', 'This');
1105
1106 assertTrue('testStrStartsWithIgnoringCase_StringMatch', tmpResult);
1107 END;
1108
1109
1110 PROCEDURE testStrStartsWithIgnoringCase_StringMatchCaseInSensitive;
1111 VAR
1112 tmpResult : Boolean;
1113 BEGIN
1114 tmpResult := StrStartsWithIgnoringCase('ThiS is a simple test', 'THis');
1115
1116 assertTrue('testStrStartsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1117 END;
1118
1119
1120 // -------------------------------------------------------------------
1121
1122
1123 PROCEDURE testStrEndsWith_BothEmpty;
1124 VAR
1125 tmpResult : Boolean;
1126 BEGIN
1127 tmpResult := StrEndsWith('', '');
1128
1129 assertTrue('testStrEndsWith_BothEmpty', tmpResult);
1130 END;
1131
1132
1133 PROCEDURE testStrEndsWith_StringEmpty;
1134 VAR
1135 tmpResult : Boolean;
1136 BEGIN
1137 tmpResult := StrEndsWith('', 'end');
1138
1139 assertFalse('testStrEndsWith_StringEmpty', tmpResult);
1140 END;
1141
1142
1143 PROCEDURE testStrEndsWith_MatchEmpty;
1144 VAR
1145 tmpResult : Boolean;
1146 BEGIN
1147 tmpResult := StrEndsWith('test', '');
1148
1149 assertTrue('testStrEndsWith_MatchEmpty', tmpResult);
1150 END;
1151
1152
1153 PROCEDURE testStrEndsWith_StringToShort;
1154 VAR
1155 tmpResult : Boolean;
1156 BEGIN
1157 tmpResult := StrEndsWith('test', 'test1');
1158
1159 assertFalse('testStrEndsWith_StringToShort', tmpResult);
1160 END;
1161
1162
1163 PROCEDURE testStrEndsWith_StringEqualLength;
1164 VAR
1165 tmpResult : Boolean;
1166 BEGIN
1167 tmpResult := StrEndsWith('test', 'best');
1168
1169 assertFalse('testStrEndsWith_StringEqualLength', tmpResult);
1170 END;
1171
1172
1173 PROCEDURE testStrEndsWith_StringEqualLengthMatch;
1174 VAR
1175 tmpResult : Boolean;
1176 BEGIN
1177 tmpResult := StrEndsWith('test', 'test');
1178
1179 assertTrue('testStrEndsWith_StringEqualLengthMatch', tmpResult);
1180 END;
1181
1182
1183 PROCEDURE testStrEndsWith_StringMatch;
1184 VAR
1185 tmpResult : Boolean;
1186 BEGIN
1187 tmpResult := StrEndsWith('a simple test', 'test');
1188
1189 assertTrue('testStrEndsWith_StringMatch', tmpResult);
1190 END;
1191
1192
1193 PROCEDURE testStrEndsWith_StringMatchCaseSensitive;
1194 VAR
1195 tmpResult : Boolean;
1196 BEGIN
1197 tmpResult := StrEndsWith('a simple tEst', 'test');
1198
1199 assertFalse('testStrEndsWith_StringMatchCaseSensitive', tmpResult);
1200 END;
1201
1202
1203 PROCEDURE testStrEndsWithIgnoringCase_BothEmpty;
1204 VAR
1205 tmpResult : Boolean;
1206 BEGIN
1207 tmpResult := StrEndsWithIgnoringCase('', '');
1208
1209 assertTrue('testStrEndsWithIgnoringCase_BothEmpty', tmpResult);
1210 END;
1211
1212
1213 PROCEDURE testStrEndsWithIgnoringCase_StringEmpty;
1214 VAR
1215 tmpResult : Boolean;
1216 BEGIN
1217 tmpResult := StrEndsWithIgnoringCase('', 'end');
1218
1219 assertFalse('testStrEndsWithIgnoringCase_StringEmpty', tmpResult);
1220 END;
1221
1222
1223 PROCEDURE testStrEndsWithIgnoringCase_MatchEmpty;
1224 VAR
1225 tmpResult : Boolean;
1226 BEGIN
1227 tmpResult := StrEndsWithIgnoringCase('test', '');
1228
1229 assertTrue('testStrEndsWithIgnoringCase_MatchEmpty', tmpResult);
1230 END;
1231
1232
1233 PROCEDURE testStrEndsWithIgnoringCase_StringToShort;
1234 VAR
1235 tmpResult : Boolean;
1236 BEGIN
1237 tmpResult := StrEndsWithIgnoringCase('test', 'test1');
1238
1239 assertFalse('testStrEndsWithIgnoringCase_StringToShort', tmpResult);
1240 END;
1241
1242
1243 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLength;
1244 VAR
1245 tmpResult : Boolean;
1246 BEGIN
1247 tmpResult := StrEndsWithIgnoringCase('test', 'best');
1248
1249 assertFalse('testStrEndsWithIgnoringCase_StringEqualLength', tmpResult);
1250 END;
1251
1252
1253 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLengthMatch;
1254 VAR
1255 tmpResult : Boolean;
1256 BEGIN
1257 tmpResult := StrEndsWithIgnoringCase('test', 'test');
1258
1259 assertTrue('testStrEndsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1260 END;
1261
1262
1263 PROCEDURE testStrEndsWithIgnoringCase_StringMatch;
1264 VAR
1265 tmpResult : Boolean;
1266 BEGIN
1267 tmpResult := StrEndsWithIgnoringCase('a simple test', 'test');
1268
1269 assertTrue('testStrEndsWithIgnoringCase_StringMatch', tmpResult);
1270 END;
1271
1272
1273 PROCEDURE testStrEndsWithIgnoringCase_StringMatchCaseInSensitive;
1274 VAR
1275 tmpResult : Boolean;
1276 BEGIN
1277 tmpResult := StrEndsWithIgnoringCase('a simple tEst', 'test');
1278
1279 assertTrue('testStrEndsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1280 END;
1281
1282
1283 // ----------------------------------------------------------
1284
1285
1286 PROCEDURE testStrEqualIgnoringCase_BothEmpty;
1287 VAR
1288 tmpResult : Boolean;
1289 BEGIN
1290 tmpResult := StrEqualIgnoringCase('', '');
1291
1292 assertTrue('testStrEqualIgnoringCase_BothEmpty', tmpResult);
1293 END;
1294
1295
1296 PROCEDURE testStrEqualIgnoringCase_FirstEmpty;
1297 VAR
1298 tmpResult : Boolean;
1299 BEGIN
1300 tmpResult := StrEqualIgnoringCase('', 'xy');
1301
1302 assertFalse('testStrEqualIgnoringCase_FirstEmpty', tmpResult);
1303 END;
1304
1305 PROCEDURE testStrEqualIgnoringCase_SecondEmpty;
1306 VAR
1307 tmpResult : Boolean;
1308 BEGIN
1309 tmpResult := StrEqualIgnoringCase('xy', '');
1310
1311 assertFalse('testStrEqualIgnoringCase_SecondEmpty', tmpResult);
1312 END;
1313
1314 PROCEDURE testStrEqualIgnoringCase_DifferentLength;
1315 VAR
1316 tmpResult : Boolean;
1317 BEGIN
1318 tmpResult := StrEqualIgnoringCase('xy', 'xyz');
1319
1320 assertFalse('testStrEqualIgnoringCase_DifferentLength', tmpResult);
1321 END;
1322
1323 PROCEDURE testStrEqualIgnoringCase_DifferentCase;
1324 VAR
1325 tmpResult : Boolean;
1326 BEGIN
1327 tmpResult := StrEqualIgnoringCase('xYz', 'xyz');
1328
1329 assertTrue('testStrEqualIgnoringCase_DifferentCase', tmpResult);
1330 END;
1331
1332 PROCEDURE testStrEqualIgnoringCase;
1333 VAR
1334 tmpResult : Boolean;
1335 BEGIN
1336 tmpResult := StrEqualIgnoringCase('XYz', 'XYz');
1337
1338 assertTrue('testStrEqualIgnoringCase', tmpResult);
1339 END;
1340
1341 // ----------------------------------------------------------
1342
1343
1344 PROCEDURE testLongWordToStr_Zero;
1345 VAR
1346 tmpResult : String;
1347 BEGIN
1348 tmpResult := LongWordToStr(0);
1349
1350 assertEqualsString('testLongWordToStr_Zero', '0', tmpResult);
1351 END;
1352
1353
1354 PROCEDURE testLongWordToStr_Four;
1355 VAR
1356 tmpResult : String;
1357 BEGIN
1358 tmpResult := LongWordToStr(4);
1359
1360 assertEqualsString('testLongWordToStr_Four', '4', tmpResult);
1361 END;
1362
1363 PROCEDURE testLongWordToStr_Max;
1364 VAR
1365 tmpResult : String;
1366 BEGIN
1367 tmpResult := LongWordToStr(4294967295);
1368
1369 assertEqualsString('testLongWordToStr_Max', '4294967295', tmpResult);
1370 END;
1371
1372
1373 // ----------------------------------------------------------
1374
1375
1376 PROCEDURE testBoolToStr_true;
1377 VAR
1378 tmpResult : String;
1379 BEGIN
1380 tmpResult := BoolToStr(true);
1381
1382 assertEqualsString('testBoolToStr_true', 'True', tmpResult);
1383 END;
1384
1385
1386 PROCEDURE testBoolToStr_false;
1387 VAR
1388 tmpResult : String;
1389 BEGIN
1390 tmpResult := BoolToStr(false);
1391
1392 assertEqualsString('testBoolToStr_false', 'False', tmpResult);
1393 END;
1394
1395
1396 // ----------------------------------------------------------
1397
1398
1399 PROCEDURE testStrInDoubleQuotes_Empty;
1400 VAR
1401 tmpResult : String;
1402 BEGIN
1403 tmpResult := StrInDoubleQuotes('');
1404
1405 assertEqualsString('testStrInDoubleQuotes_Empty', '""', tmpResult);
1406 END;
1407
1408
1409 PROCEDURE testStrInDoubleQuotes;
1410 VAR
1411 tmpResult : String;
1412 BEGIN
1413 tmpResult := StrInDoubleQuotes('abc');
1414
1415 assertEqualsString('testStrInDoubleQuotes', '"abc"', tmpResult);
1416 END;
1417
1418
1419 // ----------------------------------------------------------
1420
1421
1422 FUNCTION getStringUtilsUnitTests : TList;
1423 BEGIN
1424 result := TList.Create;
1425
1426 result.add(@testTSerializableStringList_Construction);
1427 result.add(@testTSerializableStringList_Add);
1428 result.add(@testTSerializableStringList_Get_Empty);
1429 result.add(@testTSerializableStringList_Get);
1430 result.add(@testTSerializableStringList_getSerializedString_Empty);
1431 result.add(@testTSerializableStringList_getSerializedString);
1432 result.add(@testTSerializableStringList_getSerializedString);
1433 result.add(@testTSerializableStringList_getSerializedString_WithBlanks);
1434 result.add(@testTSerializableStringList_getSerializedString_Escaping);
1435 result.add(@testTSerializableStringList_readValuesFromSerializedString);
1436 result.add(@testTSerializableStringList_readValuesFromSerializedString_quoted);
1437 result.add(@testTSerializableStringList_readValuesFromSerializedString_empty);
1438 result.add(@testTSerializableStringList_readValuesFromSerializedString_firstempty);
1439 result.add(@testTSerializableStringList_readValuesFromSerializedString_2);
1440
1441 result.add(@testEscapeAllCharsBy);
1442 result.add(@testEscapeAllCharsBy_Empty);
1443 result.add(@testEscapeAllCharsBy_EmptyChars);
1444 result.add(@testEscapeAllCharsBy_EscapeEscape);
1445
1446 result.add(@testStrExtractStrings_EmptyReceiver);
1447 result.add(@testStrExtractStrings_OnlyOnePart);
1448 result.add(@testStrExtractStrings_ManyParts);
1449 result.add(@testStrExtractStrings_StartWithDelimiter);
1450 result.add(@testStrExtractStrings_EndWithDelimiter);
1451 result.add(@testStrExtractStrings_EmptyPartInside);
1452 result.add(@testStrExtractStrings_NoDelimiter);
1453 result.add(@testStrExtractStrings_EscapedDelimiter);
1454 result.add(@testStrExtractStrings_EscapedEscapeChar);
1455 result.add(@testStrExtractStrings_DelimiterSameAsEscapeChar);
1456
1457 result.add(@testStrExtractStringsIgnoreEmpty_EmptyReceiver);
1458 result.add(@testStrExtractStringsIgnoreEmpty_OnlyOnePart);
1459 result.add(@testStrExtractStringsIgnoreEmpty_ManyParts);
1460 result.add(@testStrExtractStringsIgnoreEmpty_StartWithDelimiter);
1461 result.add(@testStrExtractStringsIgnoreEmpty_EndWithDelimiter);
1462 result.add(@testStrExtractStringsIgnoreEmpty_EmptyPartInside);
1463 result.add(@testStrExtractStringsIgnoreEmpty_NoDelimiter);
1464 result.add(@testStrExtractStringsIgnoreEmpty_EscapedDelimiter);
1465 result.add(@testStrExtractStringsIgnoreEmpty_EscapedEscapeChar);
1466
1467 result.add(@testTrimLeftChars_Empty);
1468 result.add(@testTrimLeftChars_RemoveAll);
1469 result.add(@testTrimLeftChars_OneLeft);
1470 result.add(@testTrimLeftChars_LeftOnly);
1471 result.add(@testTrimLeftChars_CharsInside);
1472 result.add(@testTrimLeftChars_Nothing);
1473
1474 result.add(@testTrimRightChars_Empty);
1475 result.add(@testTrimRightChars_RemoveAll);
1476 result.add(@testTrimRightChars_OneLeft);
1477 result.add(@testTrimRightChars_RightOnly);
1478 result.add(@testTrimRightChars_CharsInside);
1479 result.add(@testTrimRightChars_Nothing);
1480
1481 result.add(@testTrimChars_Empty);
1482 result.add(@testTrimChars_RemoveAll);
1483 result.add(@testTrimChars_OneLeftFromLeft);
1484 result.add(@testTrimChars_OneLeftFromRight);
1485 result.add(@testTrimChars_LeftOnly);
1486 result.add(@testTrimChars_RightOnly);
1487 result.add(@testTrimChars_CharsInside);
1488 result.add(@testTrimChars_Nothing);
1489
1490 result.add(@testTrim);
1491
1492 result.add(@testStrLeft_Empty);
1493 result.add(@testStrLeft_Nothing);
1494 result.add(@testStrLeft_WholeString);
1495 result.add(@testStrLeft_ToManyRequested);
1496 result.add(@testStrLeft_Part);
1497
1498 result.add(@testStrLeftWithout_Empty);
1499 result.add(@testStrLeftWithout_ToBig);
1500 result.add(@testStrLeftWithout_Negative);
1501 result.add(@testStrLeftWithout_All);
1502 result.add(@testStrLeftWithout);
1503
1504 result.add(@testStrLeftUntil_Empty);
1505 result.add(@testStrLeftUntil_Empty_EmptyDelimiterSet);
1506 result.add(@testStrLeftUntil_EmptyDelimiterSet);
1507 result.add(@testStrLeftUntil_FirstIsDelimiter);
1508 result.add(@testStrLeftUntil_LastIsDelimiter);
1509 result.add(@testStrLeftUntil_UnusedDelimiter);
1510 result.add(@testStrLeftUntil);
1511
1512 result.add(@testStrStartsWith_BothEmpty);
1513 result.add(@testStrStartsWith_StringEmpty);
1514 result.add(@testStrStartsWith_MatchEmpty);
1515 result.add(@testStrStartsWith_StringToShort);
1516 result.add(@testStrStartsWith_StringEqualLength);
1517 result.add(@testStrStartsWith_StringEqualLengthMatch);
1518 result.add(@testStrStartsWith_StringMatch);
1519 result.add(@testStrStartsWith_StringMatchCaseSensitive);
1520
1521 result.add(@testStrStartsWithIgnoringCase_BothEmpty);
1522 result.add(@testStrStartsWithIgnoringCase_StringEmpty);
1523 result.add(@testStrStartsWithIgnoringCase_MatchEmpty);
1524 result.add(@testStrStartsWithIgnoringCase_StringToShort);
1525 result.add(@testStrStartsWithIgnoringCase_StringEqualLength);
1526 result.add(@testStrStartsWithIgnoringCase_StringEqualLengthMatch);
1527 result.add(@testStrStartsWithIgnoringCase_StringMatch);
1528 result.add(@testStrStartsWithIgnoringCase_StringMatchCaseInSensitive);
1529
1530 result.add(@testStrEndsWith_BothEmpty);
1531 result.add(@testStrEndsWith_StringEmpty);
1532 result.add(@testStrEndsWith_MatchEmpty);
1533 result.add(@testStrEndsWith_StringToShort);
1534 result.add(@testStrEndsWith_StringEqualLength);
1535 result.add(@testStrEndsWith_StringEqualLengthMatch);
1536 result.add(@testStrEndsWith_StringMatch);
1537 result.add(@testStrEndsWith_StringMatchCaseSensitive);
1538
1539 result.add(@testStrEndsWithIgnoringCase_BothEmpty);
1540 result.add(@testStrEndsWithIgnoringCase_StringEmpty);
1541 result.add(@testStrEndsWithIgnoringCase_MatchEmpty);
1542 result.add(@testStrEndsWithIgnoringCase_StringToShort);
1543 result.add(@testStrEndsWithIgnoringCase_StringEqualLength);
1544 result.add(@testStrEndsWithIgnoringCase_StringEqualLengthMatch);
1545 result.add(@testStrEndsWithIgnoringCase_StringMatch);
1546 result.add(@testStrEndsWithIgnoringCase_StringMatchCaseInSensitive);
1547
1548 result.add(@testStrEqualIgnoringCase_BothEmpty);
1549 result.add(@testStrEqualIgnoringCase_FirstEmpty);
1550 result.add(@testStrEqualIgnoringCase_SecondEmpty);
1551 result.add(@testStrEqualIgnoringCase_DifferentLength);
1552 result.add(@testStrEqualIgnoringCase_DifferentCase);
1553 result.add(@testStrEqualIgnoringCase);
1554
1555 result.add(@testLongWordToStr_Zero);
1556 result.add(@testLongWordToStr_Four);
1557 result.add(@testLongWordToStr_Max);
1558
1559 result.add(@testBoolToStr_true);
1560 result.add(@testBoolToStr_false);
1561
1562 result.add(@testStrInDoubleQuotes_Empty);
1563 result.add(@testStrInDoubleQuotes);
1564 END;
1565
1566END.
Note: See TracBrowser for help on using the repository browser.