source: trunk/unittests/StringUtilsUnitTests.pas@ 384

Last change on this file since 384 was 384, checked in by RBRi, 9 years ago

move the unit test to a more central place
  • Property svn:eol-style set to native
File size: 69.1 KB
RevLine 
[35]1Unit StringUtilsUnitTests;
2
3Interface
4
5uses
6 Classes,
[110]7 SysUtils,
[35]8 TestAssert,
9 StringUtilsUnit;
10
[82]11 FUNCTION getStringUtilsUnitTests : TList;
[35]12
13
14Implementation
15
16 PROCEDURE testTSerializableStringList_Construction;
17 VAR
18 tmpResult : TSerializableStringList;
19 BEGIN
20 tmpResult := TSerializableStringList.Create;
21
22 assertEqualsInt('testTSerializableStringList_Construction', 0, tmpResult.getCount);
23
24 tmpResult.Destroy;
25 END;
26
27
28 PROCEDURE testTSerializableStringList_Add;
29 VAR
30 tmpResult : TSerializableStringList;
31 BEGIN
32 tmpResult := TSerializableStringList.Create;
33
34 tmpResult.add('Test');
35 assertEqualsInt('testTSerializableStringList_Add', 1, tmpResult.getCount);
36
37 tmpResult.Destroy;
38 END;
39
40
41 PROCEDURE testTSerializableStringList_Get_Empty;
42 VAR
43 tmpResult : TSerializableStringList;
44 BEGIN
45 tmpResult := TSerializableStringList.Create;
46
47 assertEqualsInt('testTSerializableStringList_Get_Empty', 0, tmpResult.getCount);
48
49 try
50 tmpResult.get(0);
51 except
52 on e:EListError do
53 begin
54 assertEqualsString('testTSerializableStringList_Get', 'TList error exception (EListError) occured', e.message);
55 end;
56 end;
57
58 tmpResult.Destroy;
59 END;
60
61
62 PROCEDURE testTSerializableStringList_Get;
63 VAR
64 tmpResult : TSerializableStringList;
65 BEGIN
66 tmpResult := TSerializableStringList.Create;
67
68 tmpResult.add('First');
69 tmpResult.add('Second');
70 assertEqualsInt('testTSerializableStringList_Get', 2, tmpResult.getCount);
71 assertEqualsString('testTSerializableStringList_Get', 'First', tmpResult.get(0));
72
73 tmpResult.Destroy;
74 END;
75
76
77 PROCEDURE testTSerializableStringList_getSerializedString_Empty;
78 VAR
79 tmpResult : TSerializableStringList;
80 BEGIN
81 tmpResult := TSerializableStringList.Create;
82
83 assertEqualsString('testTSerializableStringList_getSerializedString_Empty', '', tmpResult.getSerializedString);
84
85 tmpResult.Destroy;
86 END;
87
88
89 PROCEDURE testTSerializableStringList_getSerializedString;
90 VAR
91 tmpResult : TSerializableStringList;
92 BEGIN
93 tmpResult := TSerializableStringList.Create;
94
95 tmpResult.add('First');
96 tmpResult.add('Second');
97 assertEqualsString('testTSerializableStringList_getSerializedString', 'First&Second', tmpResult.getSerializedString);
98
99 tmpResult.Destroy;
100 END;
101
102
103 PROCEDURE testTSerializableStringList_getSerializedString_WithBlanks;
104 VAR
105 tmpResult : TSerializableStringList;
106 BEGIN
107 tmpResult := TSerializableStringList.Create;
108
109 tmpResult.add('Fi rst');
110 tmpResult.add('Second');
111 assertEqualsString('testTSerializableStringList_getSerializedString_WithBlanks', 'Fi rst&Second', tmpResult.getSerializedString);
112
113 tmpResult.Destroy;
114 END;
115
116
117 PROCEDURE testTSerializableStringList_getSerializedString_Escaping;
118 VAR
119 tmpResult : TSerializableStringList;
120 BEGIN
121 tmpResult := TSerializableStringList.Create;
122
123 tmpResult.add('F&i"r''st');
124 tmpResult.add('Sec&ond');
125 assertEqualsString('testTSerializableStringList_getSerializedString_WithBlanks', 'F\&i"r''st&Sec\&ond', tmpResult.getSerializedString);
126
127 tmpResult.Destroy;
128 END;
129
130
131 PROCEDURE testTSerializableStringList_readValuesFromSerializedString;
132 VAR
133 tmpResult : TSerializableStringList;
134 tmpSerialized : String;
135 BEGIN
136 tmpResult := TSerializableStringList.Create;
137
138 tmpSerialized := 'First&Second';
139
140 tmpResult.readValuesFromSerializedString(tmpSerialized);
141
142 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString', 2, tmpResult.getCount);
143 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString', 'First', tmpResult.get(0));
144 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString', 'Second', tmpResult.get(1));
145
146 tmpResult.Destroy;
147 END;
148
149
150 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_quoted;
151 VAR
152 tmpResult : TSerializableStringList;
153 tmpSerialized : String;
154 BEGIN
155 tmpResult := TSerializableStringList.Create;
156
157 tmpSerialized := 'Fi\\nrst&Se\&cond';
158
159 tmpResult.readValuesFromSerializedString(tmpSerialized);
160
161 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_quoted', 2, tmpResult.getCount);
162 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_quoted', 'Fi\nrst', tmpResult.get(0));
163 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_quoted', 'Se&cond', tmpResult.get(1));
164
165 tmpResult.Destroy;
166 END;
167
168
169 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_empty;
170 VAR
171 tmpResult : TSerializableStringList;
172 tmpSerialized : String;
173 BEGIN
174 tmpResult := TSerializableStringList.Create;
175
176 tmpSerialized := '';
177
178 tmpResult.readValuesFromSerializedString(tmpSerialized);
179
180 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_empty', 0, tmpResult.getCount);
181
182 tmpResult.Destroy;
183 END;
184
185
186 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_firstempty;
187 VAR
188 tmpResult : TSerializableStringList;
189 tmpSerialized : String;
190 BEGIN
191 tmpResult := TSerializableStringList.Create;
192
193 tmpResult.add('');
194 tmpResult.add('test');
195
196 tmpSerialized := tmpResult.getSerializedString;
197
198 tmpResult.readValuesFromSerializedString(tmpSerialized);
199
200 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_firstempty', 2, tmpResult.getCount);
201 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_firstempty', '', tmpResult.get(0));
202 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_firstempty', 'test', tmpResult.get(1));
203
204 tmpResult.Destroy;
205 END;
206
207
208 PROCEDURE testTSerializableStringList_readValuesFromSerializedString_2;
209 VAR
210 tmpResult : TSerializableStringList;
211 tmpSerialized : String;
212 BEGIN
213 tmpResult := TSerializableStringList.Create;
214
215 tmpResult.add('&test&');
216 tmpResult.add('"test"');
217 tmpResult.add('');
218 tmpResult.add('abc\&');
[65]219 tmpResult.add('\config.sys');
220
[35]221 tmpResult.add('');
222
223 tmpSerialized := tmpResult.getSerializedString;
224
225 tmpResult.readValuesFromSerializedString(tmpSerialized);
226
[65]227 assertEqualsInt('testTSerializableStringList_readValuesFromSerializedString_2', 6, tmpResult.getCount);
[35]228 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '&test&', tmpResult.get(0));
229 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '"test"', tmpResult.get(1));
230 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '', tmpResult.get(2));
231 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', 'abc\&', tmpResult.get(3));
[65]232 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '\config.sys', tmpResult.get(4));
233 assertEqualsString('testTSerializableStringList_readValuesFromSerializedString_2', '', tmpResult.get(5));
[35]234
235 tmpResult.Destroy;
236 END;
237
238
239 // ------------------------------------------------------
240
241
242 PROCEDURE testEscapeAllCharsBy_Empty;
243 VAR
244 tmpResult : String;
245 BEGIN
[41]246 tmpResult := StrEscapeAllCharsBy('', ['b'], '\');
[35]247
248 assertEqualsString('testEscapeAllCharsBy_Empty', '', tmpResult);
249 END;
250
251
252 PROCEDURE testEscapeAllCharsBy_EmptyChars;
253 VAR
254 tmpResult : String;
255 BEGIN
[41]256 tmpResult := StrEscapeAllCharsBy('abcd', [], '\');
[35]257
[41]258 assertEqualsString('testEscapeAllCharsBy_EmptyChars', 'abcd', tmpResult);
[35]259 END;
260
261
262 PROCEDURE testEscapeAllCharsBy;
263 VAR
264 tmpResult : String;
265 BEGIN
[41]266 tmpResult := StrEscapeAllCharsBy('abc', ['b'], '\');
[35]267
268 assertEqualsString('testEscapeAllCharsBy', 'a\bc', tmpResult);
269 END;
270
271
272 PROCEDURE testEscapeAllCharsBy_EscapeEscape;
273 VAR
274 tmpResult : String;
275 BEGIN
[41]276 tmpResult := StrEscapeAllCharsBy('a\bc', ['b'], '\');
[35]277
[41]278 assertEqualsString('testEscapeAllCharsBy_EscapeEscape', 'a\\\bc', tmpResult);
[35]279 END;
280
281
[139]282 PROCEDURE testEscapeAllCharsBy_NoCharactersToEscape;
283 VAR
284 tmpResult : String;
285 BEGIN
286 tmpResult := StrEscapeAllCharsBy('a\bc\\de', [], '\');
287
288 assertEqualsString('testEscapeAllCharsBy_NoCharactersToEscape', 'a\\bc\\\\de', tmpResult);
289 END;
290
291
292 PROCEDURE testEscapeAllCharsBy_DoubleDoubleQuotes;
293 VAR
294 tmpResult : String;
295 BEGIN
296 tmpResult := StrEscapeAllCharsBy('"ab cd"e', [], '"');
297
298 assertEqualsString('testEscapeAllCharsBy_DoubleDoubleQuotes', '""ab cd""e', tmpResult);
299 END;
300
301
[82]302 // ------------------------------------------------------
303
304
[41]305 PROCEDURE testStrExtractStrings_EmptyReceiver;
306 VAR
307 tmpResult : TStringList;
308 BEGIN
309 tmpResult := TStringList.Create;
310 StrExtractStrings(tmpResult, '', ['x'], '\');
311
312 assertEqualsInt('testStrExtractStrings_EmptyReceiver', 0, tmpResult.count);
313 tmpResult.Destroy;
314 END;
315
316
317 PROCEDURE testStrExtractStrings_OnlyOnePart;
318 VAR
319 tmpResult : TStringList;
320 BEGIN
321 tmpResult := TStringList.Create;
322 StrExtractStrings(tmpResult, 'abcd', ['x'], '\');
323
324 assertEqualsInt('testStrExtractStrings_OnlyOnePart', 1, tmpResult.count);
325 assertEqualsString('testStrExtractStrings_OnlyOnePart', 'abcd', tmpResult[0]);
326
327 tmpResult.Destroy;
328 END;
329
330
331 PROCEDURE testStrExtractStrings_ManyParts;
332 VAR
333 tmpResult : TStringList;
334 BEGIN
335 tmpResult := TStringList.Create;
336 StrExtractStrings(tmpResult, 'abxcd', ['x'], '\');
337
338 assertEqualsInt('testStrExtractStrings_ManyParts', 2, tmpResult.count);
339 assertEqualsString('testStrExtractStrings_ManyParts', 'ab', tmpResult[0]);
340 assertEqualsString('testStrExtractStrings_ManyParts', 'cd', tmpResult[1]);
341
342 tmpResult.Destroy;
343 END;
344
345
346 PROCEDURE testStrExtractStrings_StartWithDelimiter;
347 VAR
348 tmpResult : TStringList;
349 BEGIN
350 tmpResult := TStringList.Create;
351 StrExtractStrings(tmpResult, 'xab', ['x'], '\');
352
353 assertEqualsInt('testStrExtractStrings_StartWithDelimiter', 2, tmpResult.count);
354 assertEqualsString('testStrExtractStrings_StartWithDelimiter', '', tmpResult[0]);
355 assertEqualsString('testStrExtractStrings_StartWithDelimiter', 'ab', tmpResult[1]);
356
357 tmpResult.Destroy;
358 END;
359
360
361 PROCEDURE testStrExtractStrings_EndWithDelimiter;
362 VAR
363 tmpResult : TStringList;
364 BEGIN
365 tmpResult := TStringList.Create;
366 StrExtractStrings(tmpResult, 'abx', ['x'], '\');
367
368 assertEqualsInt('testStrExtractStrings_EndWithDelimiter', 2, tmpResult.count);
369 assertEqualsString('testStrExtractStrings_EndWithDelimiter', 'ab', tmpResult[0]);
370 assertEqualsString('testStrExtractStrings_EndWithDelimiter', '', tmpResult[1]);
371
372 tmpResult.Destroy;
373 END;
374
375
376 PROCEDURE testStrExtractStrings_EmptyPartInside;
377 VAR
378 tmpResult : TStringList;
379 BEGIN
380 tmpResult := TStringList.Create;
381 StrExtractStrings(tmpResult, 'axxb', ['x'], '\');
382
383 assertEqualsInt('testStrExtractStrings_EmptyPartInside', 3, tmpResult.count);
384 assertEqualsString('testStrExtractStrings_EmptyPartInside', 'a', tmpResult[0]);
385 assertEqualsString('testStrExtractStrings_EmptyPartInside', '', tmpResult[1]);
386 assertEqualsString('testStrExtractStrings_EmptyPartInside', 'b', tmpResult[2]);
387
388 tmpResult.Destroy;
389 END;
390
391
392 PROCEDURE testStrExtractStrings_NoDelimiter;
393 VAR
394 tmpResult : TStringList;
395 BEGIN
396 tmpResult := TStringList.Create;
397 StrExtractStrings(tmpResult, 'axxb', [], '\');
398
399 assertEqualsInt('testStrExtractStrings_NoDelimiter', 1, tmpResult.count);
400 assertEqualsString('testStrExtractStrings_NoDelimiter', 'axxb', tmpResult[0]);
401
402 tmpResult.Destroy;
403 END;
404
405
406 PROCEDURE testStrExtractStrings_EscapedDelimiter;
407 VAR
408 tmpResult : TStringList;
409 BEGIN
410 tmpResult := TStringList.Create;
411 StrExtractStrings(tmpResult, 'a\xb', ['x'], '\');
412
413 assertEqualsInt('testStrExtractStrings_EscapedDelimiter', 1, tmpResult.count);
414 assertEqualsString('testStrExtractStrings_EscapedDelimiter', 'axb', tmpResult[0]);
415
416 tmpResult.Destroy;
417 END;
418
419 PROCEDURE testStrExtractStrings_EscapedEscapeChar;
420 VAR
421 tmpResult : TStringList;
422 BEGIN
423 tmpResult := TStringList.Create;
424 StrExtractStrings(tmpResult, 'a\\xb', ['x'], '\');
425
426 assertEqualsInt('testStrExtractStrings_EscapedEscapeChar', 2, tmpResult.count);
427 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'a\', tmpResult[0]);
428 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'b', tmpResult[1]);
429
430 tmpResult.Destroy;
431 END;
432
[105]433 PROCEDURE testStrExtractStrings_DelimiterSameAsEscapeChar;
434 VAR
435 tmpResult : TStringList;
436 BEGIN
437 tmpResult := TStringList.Create;
438 StrExtractStrings(tmpResult, 'a;b;;cd;;;', [';'], ';');
[41]439
[105]440 assertEqualsInt('testStrExtractStrings_EscapedEscapeChar', 3, tmpResult.count);
441 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'a', tmpResult[0]);
442 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', 'b;cd;', tmpResult[1]);
443 assertEqualsString('testStrExtractStrings_EscapedEscapeChar', '', tmpResult[2]);
444
445 tmpResult.Destroy;
446 END;
447
[82]448 // ------------------------------------------------------
449
450
451 PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyReceiver;
452 VAR
453 tmpResult : TStringList;
454 BEGIN
455 tmpResult := TStringList.Create;
456 StrExtractStringsIgnoreEmpty(tmpResult, '', ['x'], '\');
457
458 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyReceiver', 0, tmpResult.count);
459 tmpResult.Destroy;
460 END;
461
462
463 PROCEDURE testStrExtractStringsIgnoreEmpty_OnlyOnePart;
464 VAR
465 tmpResult : TStringList;
466 BEGIN
467 tmpResult := TStringList.Create;
468 StrExtractStringsIgnoreEmpty(tmpResult, 'abcd', ['x'], '\');
469
470 assertEqualsInt('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 1, tmpResult.count);
471 assertEqualsString('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 'abcd', tmpResult[0]);
472
473 tmpResult.Destroy;
474 END;
475
476
477 PROCEDURE testStrExtractStringsIgnoreEmpty_ManyParts;
478 VAR
479 tmpResult : TStringList;
480 BEGIN
481 tmpResult := TStringList.Create;
482 StrExtractStringsIgnoreEmpty(tmpResult, 'abxcd', ['x'], '\');
483
484 assertEqualsInt('testStrExtractStringsIgnoreEmpty_ManyParts', 2, tmpResult.count);
485 assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'ab', tmpResult[0]);
486 assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'cd', tmpResult[1]);
487
488 tmpResult.Destroy;
489 END;
490
491
492 PROCEDURE testStrExtractStringsIgnoreEmpty_StartWithDelimiter;
493 VAR
494 tmpResult : TStringList;
495 BEGIN
496 tmpResult := TStringList.Create;
497 StrExtractStringsIgnoreEmpty(tmpResult, 'xab', ['x'], '\');
498
499 assertEqualsInt('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 1, tmpResult.count);
500 assertEqualsString('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 'ab', tmpResult[0]);
501
502 tmpResult.Destroy;
503 END;
504
505
506 PROCEDURE testStrExtractStringsIgnoreEmpty_EndWithDelimiter;
507 VAR
508 tmpResult : TStringList;
509 BEGIN
510 tmpResult := TStringList.Create;
511 StrExtractStringsIgnoreEmpty(tmpResult, 'abx', ['x'], '\');
512
513 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 1, tmpResult.count);
514 assertEqualsString('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 'ab', tmpResult[0]);
515
516 tmpResult.Destroy;
517 END;
518
519
520 PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyPartInside;
521 VAR
522 tmpResult : TStringList;
523 BEGIN
524 tmpResult := TStringList.Create;
525 StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', ['x'], '\');
526
527 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 2, tmpResult.count);
528 assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'a', tmpResult[0]);
529 assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'b', tmpResult[1]);
530
531 tmpResult.Destroy;
532 END;
533
534
535 PROCEDURE testStrExtractStringsIgnoreEmpty_NoDelimiter;
536 VAR
537 tmpResult : TStringList;
538 BEGIN
539 tmpResult := TStringList.Create;
540 StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', [], '\');
541
542 assertEqualsInt('testStrExtractStringsIgnoreEmpty_NoDelimiter', 1, tmpResult.count);
543 assertEqualsString('testStrExtractStringsIgnoreEmpty_NoDelimiter', 'axxb', tmpResult[0]);
544
545 tmpResult.Destroy;
546 END;
547
548
549 PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedDelimiter;
550 VAR
551 tmpResult : TStringList;
552 BEGIN
553 tmpResult := TStringList.Create;
554 StrExtractStringsIgnoreEmpty(tmpResult, 'a\xb', ['x'], '\');
555
556 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 1, tmpResult.count);
557 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 'axb', tmpResult[0]);
558
559 tmpResult.Destroy;
560 END;
561
562 PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedEscapeChar;
563 VAR
564 tmpResult : TStringList;
565 BEGIN
566 tmpResult := TStringList.Create;
567 StrExtractStringsIgnoreEmpty(tmpResult, 'a\\xb', ['x'], '\');
568
569 assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 2, tmpResult.count);
570 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'a\', tmpResult[0]);
571 assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'b', tmpResult[1]);
572
573 tmpResult.Destroy;
574 END;
575
576
577 // -------------------------------------------------------------------
578
579
580 PROCEDURE testTrimLeftChars_Empty;
581 VAR
582 tmpResult : String;
583 BEGIN
584 tmpResult := StrTrimLeftChars('', ['b', 'x']);
585
586 assertEqualsString('testTrimLeftChars_Empty', '', tmpResult);
587 END;
588
589
590 PROCEDURE testTrimLeftChars_RemoveAll;
591 VAR
592 tmpResult : String;
593 BEGIN
594 tmpResult := StrTrimLeftChars('bxxxbx', ['b', 'x']);
595
596 assertEqualsString('testTrimLeftChars_RemoveAll', '', tmpResult);
597 END;
598
599
600 PROCEDURE testTrimLeftChars_OneLeft;
601 VAR
602 tmpResult : String;
603 BEGIN
604 tmpResult := StrTrimLeftChars('bxy', ['b', 'x']);
605
606 assertEqualsString('testTrimLeftChars_OneLeft', 'y', tmpResult);
607 END;
608
609
610 PROCEDURE testTrimLeftChars_LeftOnly;
611 VAR
612 tmpResult : String;
613 BEGIN
614 tmpResult := StrTrimLeftChars('bxbxxay', ['b', 'x']);
615
616 assertEqualsString('testTrimLeftChars_LeftOnly', 'ay', tmpResult);
617 END;
618
619
620 PROCEDURE testTrimLeftChars_CharsInside;
621 VAR
622 tmpResult : String;
623 BEGIN
624 tmpResult := StrTrimLeftChars('bxabxvvx', ['b', 'x']);
625
626 assertEqualsString('testTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
627 END;
628
629
630 PROCEDURE testTrimLeftChars_Nothing;
631 VAR
632 tmpResult : String;
633 BEGIN
634 tmpResult := StrTrimLeftChars('acdef', ['b', 'x']);
635
636 assertEqualsString('testTrimLeftChars_Nothing', 'acdef', tmpResult);
637 END;
638
639
640 // -------------------------------------------------------------------
641
642
643 PROCEDURE testTrimRightChars_Empty;
644 VAR
645 tmpResult : String;
646 BEGIN
647 tmpResult := StrTrimRightChars('', ['b', 'x']);
648
649 assertEqualsString('testTrimRightChars_Empty', '', tmpResult);
650 END;
651
652
653 PROCEDURE testTrimRightChars_RemoveAll;
654 VAR
655 tmpResult : String;
656 BEGIN
657 tmpResult := StrTrimRightChars('bxxxbx', ['b', 'x']);
658
659 assertEqualsString('testTrimRightChars_RemoveAll', '', tmpResult);
660 END;
661
662
663 PROCEDURE testTrimRightChars_OneLeft;
664 VAR
665 tmpResult : String;
666 BEGIN
667 tmpResult := StrTrimRightChars('ybx', ['b', 'x']);
668
669 assertEqualsString('testTrimRightChars_OneLeft', 'y', tmpResult);
670 END;
671
672
673 PROCEDURE testTrimRightChars_RightOnly;
674 VAR
675 tmpResult : String;
676 BEGIN
677 tmpResult := StrTrimRightChars('aybxbxx', ['b', 'x']);
678
679 assertEqualsString('testTrimRightChars_RightOnly', 'ay', tmpResult);
680 END;
681
682
683 PROCEDURE testTrimRightChars_CharsInside;
684 VAR
685 tmpResult : String;
686 BEGIN
687 tmpResult := StrTrimRightChars('abxvvxb', ['b', 'x']);
688
689 assertEqualsString('testTrimRightChars_CharsInside', 'abxvv', tmpResult);
690 END;
691
692
693 PROCEDURE testTrimRightChars_Nothing;
694 VAR
695 tmpResult : String;
696 BEGIN
697 tmpResult := StrTrimRightChars('acdef', ['b', 'x']);
698
699 assertEqualsString('testTrimRightChars_Nothing', 'acdef', tmpResult);
700 END;
701
702
703 // -------------------------------------------------------------------
704
[41]705 PROCEDURE testTrimChars_Empty;
706 VAR
707 tmpResult : String;
708 BEGIN
709 tmpResult := StrTrimChars('', ['b', 'x']);
710
711 assertEqualsString('testTrimChars_Empty', '', tmpResult);
712 END;
713
714
715 PROCEDURE testTrimChars_RemoveAll;
716 VAR
717 tmpResult : String;
718 BEGIN
719 tmpResult := StrTrimChars('bxxxbx', ['b', 'x']);
720
721 assertEqualsString('testTrimChars_RemoveAll', '', tmpResult);
722 END;
723
724
[82]725 PROCEDURE testTrimChars_OneLeftFromLeft;
726 VAR
727 tmpResult : String;
728 BEGIN
729 tmpResult := StrTrimChars('bxa', ['b', 'x']);
730
731 assertEqualsString('testTrimChars_OneLeftFromLeft', 'a', tmpResult);
732 END;
733
734
735 PROCEDURE testTrimChars_OneLeftFromRight;
736 VAR
737 tmpResult : String;
738 BEGIN
739 tmpResult := StrTrimChars('abx', ['b', 'x']);
740
741 assertEqualsString('testTrimChars_OneLeftFromRight', 'a', tmpResult);
742 END;
743
744
[41]745 PROCEDURE testTrimChars_LeftOnly;
746 VAR
747 tmpResult : String;
748 BEGIN
749 tmpResult := StrTrimChars('bxbxxay', ['b', 'x']);
750
751 assertEqualsString('testTrimChars_LeftOnly', 'ay', tmpResult);
752 END;
753
754
755 PROCEDURE testTrimChars_RightOnly;
756 VAR
757 tmpResult : String;
758 BEGIN
759 tmpResult := StrTrimChars('aybxbxx', ['b', 'x']);
760
761 assertEqualsString('testTrimChars_LeftOnly', 'ay', tmpResult);
762 END;
763
764
765 PROCEDURE testTrimChars_CharsInside;
766 VAR
767 tmpResult : String;
768 BEGIN
769 tmpResult := StrTrimChars('bxabxvvx', ['b', 'x']);
770
771 assertEqualsString('testTrimChars_CharsInside', 'abxvv', tmpResult);
772 END;
773
774
775 PROCEDURE testTrimChars_Nothing;
776 VAR
777 tmpResult : String;
778 BEGIN
779 tmpResult := StrTrimChars('acdef', ['b', 'x']);
780
781 assertEqualsString('testTrimChars_Nothing', 'acdef', tmpResult);
782 END;
783
784
[82]785 // -------------------------------------------------------------------
786
787
[41]788 PROCEDURE testTrim;
789 VAR
790 tmpResult : String;
791 BEGIN
792 tmpResult := StrTrim(' a bc ');
793
794 assertEqualsString('testTrim', 'a bc', tmpResult);
795 END;
796
797
[82]798 // -------------------------------------------------------------------
799
800
801 PROCEDURE testStrLeft_Empty;
802 VAR
803 tmpResult : String;
804 BEGIN
805 tmpResult := StrLeft('', 1);
806
807 assertEqualsString('testStrLeft_Empty', '', tmpResult);
808 END;
809
810
811 PROCEDURE testStrLeft_Nothing;
812 VAR
813 tmpResult : String;
814 BEGIN
815 tmpResult := StrLeft('abc', 0);
816
817 assertEqualsString('testStrLeft_Nothing', '', tmpResult);
818 END;
819
820
821 PROCEDURE testStrLeft_WholeString;
822 VAR
823 tmpResult : String;
824 BEGIN
825 tmpResult := StrLeft('abc', 3);
826
827 assertEqualsString('testStrLeft_WholeString', 'abc', tmpResult);
828 END;
829
830 PROCEDURE testStrLeft_ToManyRequested;
831 VAR
832 tmpResult : String;
833 BEGIN
834 tmpResult := StrLeft('abc', 5);
835
836 assertEqualsString('testStrLeft_ToManyRequested', 'abc', tmpResult);
837 END;
838
839 PROCEDURE testStrLeft_Part;
840 VAR
841 tmpResult : String;
842 BEGIN
843 tmpResult := StrLeft('abcdef', 2);
844
845 assertEqualsString('testStrLeft_Part', 'ab', tmpResult);
846 END;
847
[102]848
[82]849 // -------------------------------------------------------------------
850
851
[102]852 PROCEDURE testStrLeftWithout_Empty;
853 VAR
854 tmpResult : String;
855 BEGIN
856 tmpResult := StrLeftWithout('', 4);
857
858 assertEqualsString('testStrLeftWithout_Empty', '', tmpResult);
859 END;
860
861
862 PROCEDURE testStrLeftWithout_ToBig;
863 VAR
864 tmpResult : String;
865 BEGIN
866 tmpResult := StrLeftWithout('ab', 4);
867
868 assertEqualsString('testStrLeftWithout_ToBig', '', tmpResult);
869 END;
870
871
872 PROCEDURE testStrLeftWithout_Negative;
873 VAR
874 tmpResult : String;
875 BEGIN
876 tmpResult := StrLeftWithout('ab', -1);
877
878 assertEqualsString('testStrLeftWithout_Negative', 'ab', tmpResult);
879 END;
880
881
882 PROCEDURE testStrLeftWithout_All;
883 VAR
884 tmpResult : String;
885 BEGIN
886 tmpResult := StrLeftWithout('abdefg', 6);
887
888 assertEqualsString('testStrLeftWithout_All', '', tmpResult);
889 END;
890
891
892 PROCEDURE testStrLeftWithout;
893 VAR
894 tmpResult : String;
895 BEGIN
896 tmpResult := StrLeftWithout('abdefg', 3);
897
898 assertEqualsString('testStrLeftWithout', 'abd', tmpResult);
899 END;
900
901
902 // -------------------------------------------------------------------
903
904
905 PROCEDURE testStrLeftUntil_Empty;
906 VAR
907 tmpResult : String;
908 BEGIN
909 tmpResult := StrLeftUntil('', ['b', 'x']);
910
911 assertEqualsString('testStrLeftUntil_Empty', '', tmpResult);
912 END;
913
914
915 PROCEDURE testStrLeftUntil_Empty_EmptyDelimiterSet;
916 VAR
917 tmpResult : String;
918 BEGIN
919 tmpResult := StrLeftUntil('', []);
920
921 assertEqualsString('testStrLeftUntil_Empty_EmptyDelimiterSet', '', tmpResult);
922 END;
923
924
925 PROCEDURE testStrLeftUntil_EmptyDelimiterSet;
926 VAR
927 tmpResult : String;
928 BEGIN
929 tmpResult := StrLeftUntil('abc', []);
930
931 assertEqualsString('testStrLeftUntil_EmptyDelimiterSet', 'abc', tmpResult);
932 END;
933
934
935 PROCEDURE testStrLeftUntil_FirstIsDelimiter;
936 VAR
937 tmpResult : String;
938 BEGIN
939 tmpResult := StrLeftUntil('abc', ['a']);
940
941 assertEqualsString('testStrLeftUntil_FirstIsDelimiter', '', tmpResult);
942 END;
943
944
945 PROCEDURE testStrLeftUntil_LastIsDelimiter;
946 VAR
947 tmpResult : String;
948 BEGIN
949 tmpResult := StrLeftUntil('abc', ['c']);
950
951 assertEqualsString('testStrLeftUntil_LastIsDelimiter', 'ab', tmpResult);
952 END;
953
954
955 PROCEDURE testStrLeftUntil_UnusedDelimiter;
956 VAR
957 tmpResult : String;
958 BEGIN
959 tmpResult := StrLeftUntil('abc', ['x']);
960
961 assertEqualsString('testStrLeftUntil_UnusedDelimiter', 'abc', tmpResult);
962 END;
963
964
965 PROCEDURE testStrLeftUntil;
966 VAR
967 tmpResult : String;
968 BEGIN
969 tmpResult := StrLeftUntil('abcx yz do', ['d', ' ']);
970
971 assertEqualsString('testStrLeftUntil', 'abcx', tmpResult);
972 END;
973
974
975 // -------------------------------------------------------------------
976
977
[118]978 PROCEDURE testStrSubstringFrom_Empty;
979 VAR
980 tmpResult : String;
981 BEGIN
982 tmpResult := StrSubstringFrom('', 1);
983
984 assertEqualsString('testStrSubstringFrom_Empty', '', tmpResult);
985 END;
986
987
988 PROCEDURE testStrSubstringFrom_EmptyZeroPos;
989 VAR
990 tmpResult : String;
991 BEGIN
992 tmpResult := StrSubstringFrom('', 0);
993
994 assertEqualsString('testStrSubstringFrom_EmptyZeroPos', '', tmpResult);
995 END;
996
997
998 PROCEDURE testStrSubstringFrom_EmptyNegativePos;
999 VAR
1000 tmpResult : String;
1001 BEGIN
1002 tmpResult := StrSubstringFrom('', -4);
1003
1004 assertEqualsString('testStrSubstringFrom_EmptyNegativePos', '', tmpResult);
1005 END;
1006
1007
1008 PROCEDURE testStrSubstringFrom_FullCopy;
1009 VAR
1010 tmpResult : String;
1011 BEGIN
1012 tmpResult := StrSubstringFrom('abcd', 1);
1013
1014 assertEqualsString('testStrSubstringFrom_FullCopy', 'abcd', tmpResult);
1015 END;
1016
1017
1018 PROCEDURE testStrSubstringFrom_ZeroPos;
1019 VAR
1020 tmpResult : String;
1021 BEGIN
1022 tmpResult := StrSubstringFrom('abcd', 0);
1023
1024 assertEqualsString('testStrSubstringFrom_ZeroPos', 'abcd', tmpResult);
1025 END;
1026
1027
1028 PROCEDURE testStrSubstringFrom_NegativePos;
1029 VAR
1030 tmpResult : String;
1031 BEGIN
1032 tmpResult := StrSubstringFrom('abcd', -4);
1033
1034 assertEqualsString('testStrSubstringFrom_NegativePos', 'abcd', tmpResult);
1035 END;
1036
1037
1038 PROCEDURE testStrSubstringFrom_ToBigPos;
1039 VAR
1040 tmpResult : String;
1041 BEGIN
1042 tmpResult := StrSubstringFrom('abcd', 11);
1043
1044 assertEqualsString('testStrSubstringFrom_ToBigPos', '', tmpResult);
1045 END;
1046
1047
1048 PROCEDURE testStrSubstringFrom;
1049 VAR
1050 tmpResult : String;
1051 BEGIN
1052 tmpResult := StrSubstringFrom('abcd', 2);
1053
1054 assertEqualsString('testStrSubstringFrom', 'bcd', tmpResult);
1055 END;
1056
1057
1058 // -------------------------------------------------------------------
1059
1060
[102]1061 PROCEDURE testStrStartsWith_BothEmpty;
1062 VAR
1063 tmpResult : Boolean;
1064 BEGIN
1065 tmpResult := StrStartsWith('', '');
1066
1067 assertTrue('testStrStartsWith_BothEmpty', tmpResult);
1068 END;
1069
1070
1071 PROCEDURE testStrStartsWith_StringEmpty;
1072 VAR
1073 tmpResult : Boolean;
1074 BEGIN
1075 tmpResult := StrStartsWith('', 'end');
1076
1077 assertFalse('testStrStartsWith_StringEmpty', tmpResult);
1078 END;
1079
1080
1081 PROCEDURE testStrStartsWith_MatchEmpty;
1082 VAR
1083 tmpResult : Boolean;
1084 BEGIN
1085 tmpResult := StrStartsWith('test', '');
1086
1087 assertTrue('testStrStartsWith_MatchEmpty', tmpResult);
1088 END;
1089
1090
1091 PROCEDURE testStrStartsWith_StringToShort;
1092 VAR
1093 tmpResult : Boolean;
1094 BEGIN
1095 tmpResult := StrStartsWith('test', 'test1');
1096
1097 assertFalse('testStrStartsWith_StringToShort', tmpResult);
1098 END;
1099
1100
1101 PROCEDURE testStrStartsWith_StringEqualLength;
1102 VAR
1103 tmpResult : Boolean;
1104 BEGIN
1105 tmpResult := StrStartsWith('test', 'best');
1106
1107 assertFalse('testStrStartsWith_StringEqualLength', tmpResult);
1108 END;
1109
1110
1111 PROCEDURE testStrStartsWith_StringEqualLengthMatch;
1112 VAR
1113 tmpResult : Boolean;
1114 BEGIN
1115 tmpResult := StrStartsWith('test', 'test');
1116
1117 assertTrue('testStrStartsWith_StringEqualLengthMatch', tmpResult);
1118 END;
1119
1120
1121 PROCEDURE testStrStartsWith_StringMatch;
1122 VAR
1123 tmpResult : Boolean;
1124 BEGIN
1125 tmpResult := StrStartsWith('this is a simple test', 'this');
1126
1127 assertTrue('testStrStartsWith_StringMatch', tmpResult);
1128 END;
1129
1130
1131 PROCEDURE testStrStartsWith_StringMatchCaseSensitive;
1132 VAR
1133 tmpResult : Boolean;
1134 BEGIN
1135 tmpResult := StrStartsWith('This is a simple test', 'tHis');
1136
1137 assertFalse('testStrStartsWith_StringMatchCaseSensitive', tmpResult);
1138 END;
1139
1140
1141 // -------------------------------------------------------------------
1142
1143
1144 PROCEDURE testStrStartsWithIgnoringCase_BothEmpty;
1145 VAR
1146 tmpResult : Boolean;
1147 BEGIN
1148 tmpResult := StrStartsWithIgnoringCase('', '');
1149
1150 assertTrue('testStrStartsWithIgnoringCase_BothEmpty', tmpResult);
1151 END;
1152
1153
1154 PROCEDURE testStrStartsWithIgnoringCase_StringEmpty;
1155 VAR
1156 tmpResult : Boolean;
1157 BEGIN
1158 tmpResult := StrStartsWithIgnoringCase('', 'end');
1159
1160 assertFalse('testStrStartsWithIgnoringCase_StringEmpty', tmpResult);
1161 END;
1162
1163
1164 PROCEDURE testStrStartsWithIgnoringCase_MatchEmpty;
1165 VAR
1166 tmpResult : Boolean;
1167 BEGIN
1168 tmpResult := StrStartsWithIgnoringCase('test', '');
1169
1170 assertTrue('testStrStartsWithIgnoringCase_MatchEmpty', tmpResult);
1171 END;
1172
1173
1174 PROCEDURE testStrStartsWithIgnoringCase_StringToShort;
1175 VAR
1176 tmpResult : Boolean;
1177 BEGIN
1178 tmpResult := StrStartsWithIgnoringCase('test', 'test1');
1179
1180 assertFalse('testStrStartsWithIgnoringCase_StringToShort', tmpResult);
1181 END;
1182
1183
1184 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLength;
1185 VAR
1186 tmpResult : Boolean;
1187 BEGIN
1188 tmpResult := StrStartsWithIgnoringCase('test', 'best');
1189
1190 assertFalse('testStrStartsWithIgnoringCase_StringEqualLength', tmpResult);
1191 END;
1192
1193
1194 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLengthMatch;
1195 VAR
1196 tmpResult : Boolean;
1197 BEGIN
1198 tmpResult := StrStartsWithIgnoringCase('test', 'test');
1199
1200 assertTrue('testStrStartsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1201 END;
1202
1203
1204 PROCEDURE testStrStartsWithIgnoringCase_StringMatch;
1205 VAR
1206 tmpResult : Boolean;
1207 BEGIN
1208 tmpResult := StrStartsWithIgnoringCase('This is a simple test', 'This');
1209
1210 assertTrue('testStrStartsWithIgnoringCase_StringMatch', tmpResult);
1211 END;
1212
1213
1214 PROCEDURE testStrStartsWithIgnoringCase_StringMatchCaseInSensitive;
1215 VAR
1216 tmpResult : Boolean;
1217 BEGIN
1218 tmpResult := StrStartsWithIgnoringCase('ThiS is a simple test', 'THis');
1219
1220 assertTrue('testStrStartsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1221 END;
1222
1223
1224 // -------------------------------------------------------------------
1225
1226
[41]1227 PROCEDURE testStrEndsWith_BothEmpty;
1228 VAR
1229 tmpResult : Boolean;
1230 BEGIN
1231 tmpResult := StrEndsWith('', '');
1232
1233 assertTrue('testStrEndsWith_BothEmpty', tmpResult);
1234 END;
1235
1236
1237 PROCEDURE testStrEndsWith_StringEmpty;
1238 VAR
1239 tmpResult : Boolean;
1240 BEGIN
1241 tmpResult := StrEndsWith('', 'end');
1242
1243 assertFalse('testStrEndsWith_StringEmpty', tmpResult);
1244 END;
1245
1246
1247 PROCEDURE testStrEndsWith_MatchEmpty;
1248 VAR
1249 tmpResult : Boolean;
1250 BEGIN
1251 tmpResult := StrEndsWith('test', '');
1252
1253 assertTrue('testStrEndsWith_MatchEmpty', tmpResult);
1254 END;
1255
1256
1257 PROCEDURE testStrEndsWith_StringToShort;
1258 VAR
1259 tmpResult : Boolean;
1260 BEGIN
1261 tmpResult := StrEndsWith('test', 'test1');
1262
1263 assertFalse('testStrEndsWith_StringToShort', tmpResult);
1264 END;
1265
1266
1267 PROCEDURE testStrEndsWith_StringEqualLength;
1268 VAR
1269 tmpResult : Boolean;
1270 BEGIN
1271 tmpResult := StrEndsWith('test', 'best');
1272
1273 assertFalse('testStrEndsWith_StringEqualLength', tmpResult);
1274 END;
1275
1276
1277 PROCEDURE testStrEndsWith_StringEqualLengthMatch;
1278 VAR
1279 tmpResult : Boolean;
1280 BEGIN
1281 tmpResult := StrEndsWith('test', 'test');
1282
1283 assertTrue('testStrEndsWith_StringEqualLengthMatch', tmpResult);
1284 END;
1285
1286
1287 PROCEDURE testStrEndsWith_StringMatch;
1288 VAR
1289 tmpResult : Boolean;
1290 BEGIN
1291 tmpResult := StrEndsWith('a simple test', 'test');
1292
1293 assertTrue('testStrEndsWith_StringMatch', tmpResult);
1294 END;
1295
1296
1297 PROCEDURE testStrEndsWith_StringMatchCaseSensitive;
1298 VAR
1299 tmpResult : Boolean;
1300 BEGIN
1301 tmpResult := StrEndsWith('a simple tEst', 'test');
1302
1303 assertFalse('testStrEndsWith_StringMatchCaseSensitive', tmpResult);
1304 END;
1305
1306
1307 PROCEDURE testStrEndsWithIgnoringCase_BothEmpty;
1308 VAR
1309 tmpResult : Boolean;
1310 BEGIN
1311 tmpResult := StrEndsWithIgnoringCase('', '');
1312
1313 assertTrue('testStrEndsWithIgnoringCase_BothEmpty', tmpResult);
1314 END;
1315
1316
1317 PROCEDURE testStrEndsWithIgnoringCase_StringEmpty;
1318 VAR
1319 tmpResult : Boolean;
1320 BEGIN
1321 tmpResult := StrEndsWithIgnoringCase('', 'end');
1322
1323 assertFalse('testStrEndsWithIgnoringCase_StringEmpty', tmpResult);
1324 END;
1325
1326
1327 PROCEDURE testStrEndsWithIgnoringCase_MatchEmpty;
1328 VAR
1329 tmpResult : Boolean;
1330 BEGIN
1331 tmpResult := StrEndsWithIgnoringCase('test', '');
1332
1333 assertTrue('testStrEndsWithIgnoringCase_MatchEmpty', tmpResult);
1334 END;
1335
1336
1337 PROCEDURE testStrEndsWithIgnoringCase_StringToShort;
1338 VAR
1339 tmpResult : Boolean;
1340 BEGIN
1341 tmpResult := StrEndsWithIgnoringCase('test', 'test1');
1342
1343 assertFalse('testStrEndsWithIgnoringCase_StringToShort', tmpResult);
1344 END;
1345
1346
1347 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLength;
1348 VAR
1349 tmpResult : Boolean;
1350 BEGIN
1351 tmpResult := StrEndsWithIgnoringCase('test', 'best');
1352
1353 assertFalse('testStrEndsWithIgnoringCase_StringEqualLength', tmpResult);
1354 END;
1355
1356
1357 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLengthMatch;
1358 VAR
1359 tmpResult : Boolean;
1360 BEGIN
1361 tmpResult := StrEndsWithIgnoringCase('test', 'test');
1362
1363 assertTrue('testStrEndsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1364 END;
1365
1366
1367 PROCEDURE testStrEndsWithIgnoringCase_StringMatch;
1368 VAR
1369 tmpResult : Boolean;
1370 BEGIN
1371 tmpResult := StrEndsWithIgnoringCase('a simple test', 'test');
1372
1373 assertTrue('testStrEndsWithIgnoringCase_StringMatch', tmpResult);
1374 END;
1375
1376
1377 PROCEDURE testStrEndsWithIgnoringCase_StringMatchCaseInSensitive;
1378 VAR
1379 tmpResult : Boolean;
1380 BEGIN
1381 tmpResult := StrEndsWithIgnoringCase('a simple tEst', 'test');
1382
1383 assertTrue('testStrEndsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1384 END;
1385
1386
[105]1387 // ----------------------------------------------------------
1388
1389
[139]1390 PROCEDURE testStrIsEmptyOrSpaces_Empty;
1391 VAR
1392 tmpResult : Boolean;
1393 BEGIN
1394 tmpResult := StrIsEmptyOrSpaces('');
1395
1396 assertTrue('testStrIsEmptyOrSpaces_Empty', tmpResult);
1397 END;
1398
1399
1400 PROCEDURE testStrIsEmptyOrSpaces_OneSpace;
1401 VAR
1402 tmpResult : Boolean;
1403 BEGIN
1404 tmpResult := StrIsEmptyOrSpaces(' ');
1405
1406 assertTrue('testStrIsEmptyOrSpaces_OneSpace', tmpResult);
1407 END;
1408
1409
1410 PROCEDURE testStrIsEmptyOrSpaces_ManySpaces;
1411 VAR
1412 tmpResult : Boolean;
1413 BEGIN
1414 tmpResult := StrIsEmptyOrSpaces(' ');
1415
1416 assertTrue('testStrIsEmptyOrSpaces_ManySpaces', tmpResult);
1417 END;
1418
1419
1420 PROCEDURE testStrIsEmptyOrSpaces_OneChar;
1421 VAR
1422 tmpResult : Boolean;
1423 BEGIN
1424 tmpResult := StrIsEmptyOrSpaces('a');
1425
1426 assertFalse('testStrIsEmptyOrSpaces_OneChar', tmpResult);
1427 END;
1428
1429
1430 PROCEDURE testStrIsEmptyOrSpaces_ManyChars;
1431 VAR
1432 tmpResult : Boolean;
1433 BEGIN
1434 tmpResult := StrIsEmptyOrSpaces('abcde');
1435
1436 assertFalse('testStrIsEmptyOrSpaces_ManyChars', tmpResult);
1437 END;
1438
1439
1440 PROCEDURE testStrIsEmptyOrSpaces_SpacesWithOneChar;
1441 VAR
1442 tmpResult : Boolean;
1443 BEGIN
1444 tmpResult := StrIsEmptyOrSpaces(' z ');
1445
1446 assertFalse('testStrIsEmptyOrSpaces_SpacesWithOneChar', tmpResult);
1447 END;
1448
1449
1450 PROCEDURE testStrIsEmptyOrSpaces_CharZero;
1451 VAR
1452 tmpResult : Boolean;
1453 BEGIN
1454 tmpResult := StrIsEmptyOrSpaces(#0);
1455
1456 assertFalse('testStrIsEmptyOrSpaces_CharZero', tmpResult);
1457 END;
1458
1459
1460 // ----------------------------------------------------------
1461
1462
[105]1463 PROCEDURE testStrEqualIgnoringCase_BothEmpty;
1464 VAR
1465 tmpResult : Boolean;
1466 BEGIN
1467 tmpResult := StrEqualIgnoringCase('', '');
1468
1469 assertTrue('testStrEqualIgnoringCase_BothEmpty', tmpResult);
1470 END;
1471
1472
1473 PROCEDURE testStrEqualIgnoringCase_FirstEmpty;
1474 VAR
1475 tmpResult : Boolean;
1476 BEGIN
1477 tmpResult := StrEqualIgnoringCase('', 'xy');
1478
1479 assertFalse('testStrEqualIgnoringCase_FirstEmpty', tmpResult);
1480 END;
1481
1482 PROCEDURE testStrEqualIgnoringCase_SecondEmpty;
1483 VAR
1484 tmpResult : Boolean;
1485 BEGIN
1486 tmpResult := StrEqualIgnoringCase('xy', '');
1487
1488 assertFalse('testStrEqualIgnoringCase_SecondEmpty', tmpResult);
1489 END;
1490
1491 PROCEDURE testStrEqualIgnoringCase_DifferentLength;
1492 VAR
1493 tmpResult : Boolean;
1494 BEGIN
1495 tmpResult := StrEqualIgnoringCase('xy', 'xyz');
1496
1497 assertFalse('testStrEqualIgnoringCase_DifferentLength', tmpResult);
1498 END;
1499
1500 PROCEDURE testStrEqualIgnoringCase_DifferentCase;
1501 VAR
1502 tmpResult : Boolean;
1503 BEGIN
1504 tmpResult := StrEqualIgnoringCase('xYz', 'xyz');
1505
1506 assertTrue('testStrEqualIgnoringCase_DifferentCase', tmpResult);
1507 END;
1508
1509 PROCEDURE testStrEqualIgnoringCase;
1510 VAR
1511 tmpResult : Boolean;
1512 BEGIN
1513 tmpResult := StrEqualIgnoringCase('XYz', 'XYz');
1514
1515 assertTrue('testStrEqualIgnoringCase', tmpResult);
1516 END;
1517
1518 // ----------------------------------------------------------
1519
1520
[68]1521 PROCEDURE testLongWordToStr_Zero;
1522 VAR
1523 tmpResult : String;
1524 BEGIN
1525 tmpResult := LongWordToStr(0);
1526
1527 assertEqualsString('testLongWordToStr_Zero', '0', tmpResult);
1528 END;
1529
1530
1531 PROCEDURE testLongWordToStr_Four;
1532 VAR
1533 tmpResult : String;
1534 BEGIN
1535 tmpResult := LongWordToStr(4);
1536
1537 assertEqualsString('testLongWordToStr_Four', '4', tmpResult);
1538 END;
1539
1540 PROCEDURE testLongWordToStr_Max;
1541 VAR
1542 tmpResult : String;
1543 BEGIN
1544 tmpResult := LongWordToStr(4294967295);
1545
1546 assertEqualsString('testLongWordToStr_Max', '4294967295', tmpResult);
1547 END;
1548
1549
[105]1550 // ----------------------------------------------------------
[68]1551
[105]1552
[65]1553 PROCEDURE testBoolToStr_true;
1554 VAR
1555 tmpResult : String;
1556 BEGIN
1557 tmpResult := BoolToStr(true);
1558
1559 assertEqualsString('testBoolToStr_true', 'True', tmpResult);
1560 END;
1561
1562
1563 PROCEDURE testBoolToStr_false;
1564 VAR
1565 tmpResult : String;
1566 BEGIN
1567 tmpResult := BoolToStr(false);
1568
1569 assertEqualsString('testBoolToStr_false', 'False', tmpResult);
1570 END;
1571
[105]1572
[35]1573 // ----------------------------------------------------------
1574
1575
[139]1576 PROCEDURE testStrInSingleQuotes_Empty;
1577 VAR
1578 tmpResult : String;
1579 BEGIN
1580 tmpResult := StrInSingleQuotes('');
1581
1582 assertEqualsString('testStrInSingleQuotes_Empty', '''''', tmpResult);
1583 END;
1584
1585
1586 PROCEDURE testStrInSingleQuotes;
1587 VAR
1588 tmpResult : String;
1589 BEGIN
1590 tmpResult := StrInSingleQuotes('abc');
1591
1592 assertEqualsString('testStrInSingleQuotes', '''abc''', tmpResult);
1593 END;
1594
1595
1596 // ----------------------------------------------------------
1597
1598
[102]1599 PROCEDURE testStrInDoubleQuotes_Empty;
1600 VAR
1601 tmpResult : String;
1602 BEGIN
1603 tmpResult := StrInDoubleQuotes('');
1604
1605 assertEqualsString('testStrInDoubleQuotes_Empty', '""', tmpResult);
1606 END;
1607
1608
1609 PROCEDURE testStrInDoubleQuotes;
1610 VAR
1611 tmpResult : String;
1612 BEGIN
1613 tmpResult := StrInDoubleQuotes('abc');
1614
1615 assertEqualsString('testStrInDoubleQuotes', '"abc"', tmpResult);
1616 END;
1617
1618
1619 // ----------------------------------------------------------
1620
1621
[106]1622 PROCEDURE testStrExtractStringsQuoted_Empty;
1623 VAR
1624 tmpResult : TStringList;
1625 tmpString : String;
1626 BEGIN
1627 tmpResult := TStringList.Create;
1628 tmpString := '';
1629
1630 StrExtractStringsQuoted(tmpResult, tmpString);
1631 assertEqualsInt('testStrExtractStringsQuoted_Empty', 0, tmpResult.count);
1632
1633 tmpResult.Destroy;
1634 END;
1635
1636
1637 PROCEDURE testStrExtractStringsQuoted_OnlyWhitespace;
1638 VAR
1639 tmpResult : TStringList;
1640 tmpString : String;
1641 BEGIN
1642 tmpResult := TStringList.Create;
1643 tmpString := ' ' + StrTAB + ' ';
1644
1645 StrExtractStringsQuoted(tmpResult, tmpString);
1646 assertEqualsInt('testStrExtractStringsQuoted_OnlyWhitespace', 0, tmpResult.count);
1647
1648 tmpResult.Destroy;
1649 END;
1650
1651
1652 PROCEDURE testStrExtractStringsQuoted_OnlyText;
1653 VAR
1654 tmpResult : TStringList;
1655 tmpString : String;
1656 BEGIN
1657 tmpResult := TStringList.Create;
1658 tmpString := 'TeXt';
1659
1660 StrExtractStringsQuoted(tmpResult, tmpString);
1661 assertEqualsInt('testStrExtractStringsQuoted_OnlyText', 1, tmpResult.count);
1662 assertEqualsString('testStrExtractStringsQuoted_OnlyText', 'TeXt', tmpResult[0]);
1663
1664 tmpResult.Destroy;
1665 END;
1666
1667
1668 PROCEDURE testStrExtractStringsQuoted_OnlyText2Parts;
1669 VAR
1670 tmpResult : TStringList;
1671 tmpString : String;
1672 BEGIN
1673 tmpResult := TStringList.Create;
1674 tmpString := 'TeXt sample';
1675
1676 StrExtractStringsQuoted(tmpResult, tmpString);
1677 assertEqualsInt('testStrExtractStringsQuoted_OnlyText2Parts', 2, tmpResult.count);
1678 assertEqualsString('testStrExtractStringsQuoted_OnlyText2Parts', 'TeXt', tmpResult[0]);
1679 assertEqualsString('testStrExtractStringsQuoted_OnlyText2Parts', 'sample', tmpResult[1]);
1680
1681 tmpResult.Destroy;
1682 END;
1683
1684
1685 PROCEDURE testStrExtractStringsQuoted_TextAndWhitespace2Parts;
1686 VAR
1687 tmpResult : TStringList;
1688 tmpString : String;
1689 BEGIN
1690 tmpResult := TStringList.Create;
1691 tmpString := ' TeXt ' + StrTAB + StrTAB + ' sample ' + StrTAB;
1692
1693 StrExtractStringsQuoted(tmpResult, tmpString);
1694 assertEqualsInt('testStrExtractStringsQuoted_TextAndWhitespace2Parts', 2, tmpResult.count);
1695 assertEqualsString('testStrExtractStringsQuoted_TextAndWhitespace2Parts', 'TeXt', tmpResult[0]);
1696 assertEqualsString('testStrExtractStringsQuoted_TextAndWhitespace2Parts', 'sample', tmpResult[1]);
1697
1698 tmpResult.Destroy;
1699 END;
1700
1701
1702 PROCEDURE testStrExtractStringsQuoted_QuotedText1Part;
1703 VAR
1704 tmpResult : TStringList;
1705 tmpString : String;
1706 BEGIN
1707 tmpResult := TStringList.Create;
1708 tmpString := '"TeXt"';
1709
1710 StrExtractStringsQuoted(tmpResult, tmpString);
1711 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1Part', 1, tmpResult.count);
1712 assertEqualsString('testStrExtractStringsQuoted_QuotedText1Part', 'TeXt', tmpResult[0]);
1713
1714 tmpResult.Destroy;
1715 END;
1716
1717
1718 PROCEDURE testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes;
1719 VAR
1720 tmpResult : TStringList;
1721 tmpString : String;
1722 BEGIN
1723 tmpResult := TStringList.Create;
1724 tmpString := '"TeXt';
1725
1726 StrExtractStringsQuoted(tmpResult, tmpString);
1727 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes', 1, tmpResult.count);
1728 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes', 'TeXt', tmpResult[0]);
1729
1730 tmpResult.Destroy;
1731 END;
1732
1733
1734 PROCEDURE testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace;
1735 VAR
1736 tmpResult : TStringList;
1737 tmpString : String;
1738 BEGIN
1739 tmpResult := TStringList.Create;
1740 tmpString := '"TeX t ';
1741
1742 StrExtractStringsQuoted(tmpResult, tmpString);
1743 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace', 1, tmpResult.count);
1744 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace', 'TeX t ', tmpResult[0]);
1745
1746 tmpResult.Destroy;
1747 END;
1748
1749
1750
1751
1752 PROCEDURE testStrExtractStringsQuoted_QuotedText1PartQuoteInside;
1753 VAR
1754 tmpResult : TStringList;
1755 tmpString : String;
1756 BEGIN
1757 tmpResult := TStringList.Create;
1758 tmpString := '"TeX"t';
1759
1760 StrExtractStringsQuoted(tmpResult, tmpString);
1761 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1PartQuoteInside', 2, tmpResult.count);
1762 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartQuoteInside', 'TeX', tmpResult[0]);
1763 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartQuoteInside', 't', tmpResult[1]);
1764
1765 tmpResult.Destroy;
1766 END;
1767
1768
1769 PROCEDURE testStrExtractStringsQuoted_QuotedText1Part2QuotesInside;
1770 VAR
1771 tmpResult : TStringList;
1772 tmpString : String;
1773 BEGIN
1774 tmpResult := TStringList.Create;
1775 tmpString := '"TeX""t"';
1776
1777 StrExtractStringsQuoted(tmpResult, tmpString);
1778 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1Part2QuotesInside', 1, tmpResult.count);
1779 assertEqualsString('testStrExtractStringsQuoted_QuotedText1Part2QuotesInside', 'TeX"t', tmpResult[0]);
1780
1781 tmpResult.Destroy;
1782 END;
1783
1784
1785 PROCEDURE testStrExtractStringsQuoted_QuotedText1Part2Quotes;
1786 VAR
1787 tmpResult : TStringList;
1788 tmpString : String;
1789 BEGIN
1790 tmpResult := TStringList.Create;
1791 tmpString := '"""Te X""t"""';
1792
1793 StrExtractStringsQuoted(tmpResult, tmpString);
1794 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1Part2Quotes', 1, tmpResult.count);
1795 assertEqualsString('testStrExtractStringsQuoted_QuotedText1Part2Quotes', '"Te X"t"', tmpResult[0]);
1796
1797 tmpResult.Destroy;
1798 END;
1799
1800
1801 PROCEDURE testStrExtractStringsQuoted_Only1Quote;
1802 VAR
1803 tmpResult : TStringList;
1804 tmpString : String;
1805 BEGIN
1806 tmpResult := TStringList.Create;
1807 tmpString := '"';
1808
1809 StrExtractStringsQuoted(tmpResult, tmpString);
1810 assertEqualsInt('testStrExtractStringsQuoted_Only1Quote', 0, tmpResult.count);
1811
1812 tmpResult.Destroy;
1813 END;
1814
1815
1816 PROCEDURE testStrExtractStringsQuoted_Only1QuoteAndWhitespace;
1817 VAR
1818 tmpResult : TStringList;
1819 tmpString : String;
1820 BEGIN
1821 tmpResult := TStringList.Create;
1822 tmpString := ' " ';
1823
1824 StrExtractStringsQuoted(tmpResult, tmpString);
1825 assertEqualsInt('testStrExtractStringsQuoted_Only1QuoteAndWhitespace', 1, tmpResult.count);
1826 assertEqualsString('testStrExtractStringsQuoted_Only1QuoteAndWhitespace', ' ', tmpResult[0]);
1827
1828 tmpResult.Destroy;
1829 END;
1830
1831
1832 PROCEDURE testStrExtractStringsQuoted_QuoteStartsNewPart;
1833 VAR
1834 tmpResult : TStringList;
1835 tmpString : String;
1836 BEGIN
1837 tmpResult := TStringList.Create;
1838 tmpString := 'ab"c"';
1839
1840 StrExtractStringsQuoted(tmpResult, tmpString);
1841 assertEqualsInt('testStrExtractStringsQuoted_QuoteStartsNewPart', 2, tmpResult.count);
1842 assertEqualsString('testStrExtractStringsQuoted_QuoteStartsNewPart', 'ab', tmpResult[0]);
1843 assertEqualsString('testStrExtractStringsQuoted_QuoteStartsNewPart', 'c', tmpResult[1]);
1844
1845 // note this is not compatible with the old behavior but more consistent
1846 // tmpIndex := 1;
1847 // GetNextQuotedValue(tmpString, tmpIndex, s, '"');
1848 // assertEqualsString('testGetNextQuotedValue', 'ab"c"', s);
1849
1850 tmpResult.Destroy;
1851 END;
1852
1853
1854 PROCEDURE testStrExtractStringsQuoted_ManyParts;
1855 VAR
1856 tmpResult : TStringList;
1857 tmpString : String;
1858 BEGIN
1859 tmpResult := TStringList.Create;
1860 tmpString := 'ab "c" """d" xy z ""';
1861
1862 StrExtractStringsQuoted(tmpResult, tmpString);
1863 assertEqualsInt('testStrExtractStringsQuoted_ManyParts', 6, tmpResult.count);
1864 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'ab', tmpResult[0]);
1865 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'c', tmpResult[1]);
1866 assertEqualsString('testStrExtractStringsQuoted_ManyParts', '"d', tmpResult[2]);
1867 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'xy', tmpResult[3]);
1868 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'z', tmpResult[4]);
1869 assertEqualsString('testStrExtractStringsQuoted_ManyParts', '', tmpResult[5]);
1870
1871 tmpResult.Destroy;
1872 END;
1873
1874
1875 // ----------------------------------------------------------
1876
1877
[110]1878 PROCEDURE testCaseInsensitivePos_Empty;
1879 VAR
1880 tmpResult : longint;
1881 BEGIN
1882 tmpResult := CaseInsensitivePos('', '');
[106]1883
[110]1884 assertEqualsInt('testCaseInsensitivePos_Empty', Pos('', ''), tmpResult);
1885 END;
1886
1887
1888 PROCEDURE testCaseInsensitivePos_EmptyPart;
1889 VAR
1890 tmpResult : longint;
1891 BEGIN
1892 tmpResult := CaseInsensitivePos('', 'abc');
1893
1894 assertEqualsInt('testCaseInsensitivePos_EmptyPart', Pos('', 'abc'), tmpResult);
1895 END;
1896
1897
1898 PROCEDURE testCaseInsensitivePos_EmptyString;
1899 VAR
1900 tmpResult : longint;
1901 BEGIN
1902 tmpResult := CaseInsensitivePos('abc', '');
1903
1904 assertEqualsInt('testCaseInsensitivePos_EmptyString', Pos('abc', ''), tmpResult);
1905 END;
1906
1907
1908 PROCEDURE testCaseInsensitivePos_PartLarger;
1909 VAR
1910 tmpResult : longint;
1911 BEGIN
1912 tmpResult := CaseInsensitivePos('abc', 'ab');
1913
1914 assertEqualsInt('testCaseInsensitivePos_PartLarger', Pos('abc', 'ab'), tmpResult);
1915 END;
1916
1917
1918 PROCEDURE testCaseInsensitivePos_AtLeft;
1919 VAR
1920 tmpResult : integer;
1921 BEGIN
1922 tmpResult := CaseInsensitivePos('abCd', 'aBcDef');
1923
1924 assertEqualsInt('testCaseInsensitivePos_AtLeft', Pos('abcd', 'abcdef'), tmpResult);
1925 END;
1926
1927
1928 PROCEDURE testCaseInsensitivePos_Middle;
1929 VAR
1930 tmpResult : integer;
1931 BEGIN
1932 tmpResult := CaseInsensitivePos('abCd', '12aBcDef');
1933
1934 assertEqualsInt('testCaseInsensitivePos_Middle', Pos('abcd', '12abcdef'), tmpResult);
1935 END;
1936
1937
1938 PROCEDURE testCaseInsensitivePos_AtRight;
1939 VAR
1940 tmpResult : integer;
1941 BEGIN
1942 tmpResult := CaseInsensitivePos('abCd', 'efaBcD');
1943
1944 assertEqualsInt('testCaseInsensitivePos_AtRight', Pos('abcd', 'efabcd'), tmpResult);
1945 END;
1946
1947
1948 PROCEDURE testCaseInsensitivePos;
1949 VAR
1950 tmpPart : String;
1951 tmpString : String;
1952 tmpResult,i : integer;
1953 BEGIN
1954 tmpPart := '';
1955 tmpString := '';
1956
1957 for i:=1 to 255 do
1958 begin
1959 tmpPart := tmpPart + char(i);
1960 tmpString := tmpString + char(i);
1961 end;
1962
1963 tmpResult := CaseInsensitivePos(tmpPart, UpperCase(tmpString));
1964 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1965
1966 tmpResult := CaseInsensitivePos(UpperCase(tmpPart), tmpString);
1967 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1968
1969 tmpResult := CaseInsensitivePos(tmpPart, LowerCase(tmpString));
1970 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1971
1972 tmpResult := CaseInsensitivePos(LowerCase(tmpPart), tmpString);
1973 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
[139]1974 END;
[110]1975
1976
[384]1977
[139]1978 // -------------------------------------------------------------------
1979
1980
1981 PROCEDURE testLastPosOfChar_Empty;
1982 VAR
1983 tmpResult : longint;
1984 BEGIN
1985 tmpResult := LastPosOfChar('x', '');
1986
1987 assertEqualsInt('testLastPosOfChar_Empty', 0, tmpResult);
1988 END;
1989
1990
1991 PROCEDURE testLastPosOfChar_NotFound;
1992 VAR
1993 tmpResult : longint;
1994 BEGIN
1995 tmpResult := LastPosOfChar('x', 'abcd');
1996
1997 assertEqualsInt('testLastPosOfChar_NotFound', 0, tmpResult);
1998 END;
1999
2000
2001 PROCEDURE testLastPosOfChar_OneCharNotFound;
2002 VAR
2003 tmpResult : longint;
2004 BEGIN
2005 tmpResult := LastPosOfChar('x', 'a');
2006
2007 assertEqualsInt('testLastPosOfChar_OneCharNotFound', 0, tmpResult);
2008 END;
2009
2010
2011 PROCEDURE testLastPosOfChar_OneCharFound;
2012 VAR
2013 tmpResult : longint;
2014 BEGIN
2015 tmpResult := LastPosOfChar('x', 'x');
2016
2017 assertEqualsInt('testLastPosOfChar_OneCharFound', 1, tmpResult);
2018 END;
2019
2020
2021 PROCEDURE testLastPosOfChar_OneCharWrongCase;
2022 VAR
2023 tmpResult : longint;
2024 BEGIN
2025 tmpResult := LastPosOfChar('x', 'X');
2026
2027 assertEqualsInt('testLastPosOfChar_OneCharWrongCase', 0, tmpResult);
2028 END;
2029
2030
2031 PROCEDURE testLastPosOfChar_FirstChar;
2032 VAR
2033 tmpResult : longint;
2034 BEGIN
2035 tmpResult := LastPosOfChar('x', 'xabcd');
2036
2037 assertEqualsInt('testLastPosOfChar_FirstChar', 1, tmpResult);
2038 END;
2039
2040
2041 PROCEDURE testLastPosOfChar_LastChar;
2042 VAR
2043 tmpResult : longint;
2044 BEGIN
2045 tmpResult := LastPosOfChar('x', 'abcdx');
2046
2047 assertEqualsInt('testLastPosOfChar_LastChar', 5, tmpResult);
2048 END;
2049
2050
2051 PROCEDURE testLastPosOfChar_MiddleChar;
2052 VAR
2053 tmpResult : longint;
2054 BEGIN
2055 tmpResult := LastPosOfChar('x', 'abcdxwertzu');
2056
2057 assertEqualsInt('testLastPosOfChar_MiddleChar', 5, tmpResult);
2058 END;
2059
2060
2061 PROCEDURE testLastPosOfChar_ManyHits;
2062 VAR
2063 tmpResult : longint;
2064 BEGIN
2065 tmpResult := LastPosOfChar('x', 'axbcxdxu');
2066
2067 assertEqualsInt('testLastPosOfChar_ManyHits', 7, tmpResult);
2068 END;
2069
2070
[110]2071 // --------------------
2072 // ---- AnsiString ----
2073 // --------------------
2074
2075
2076 PROCEDURE testAnsiTrimLeftChars_Empty;
2077 VAR
2078 tmpResult : AnsiString;
2079 tmpValue : AnsiString;
2080 BEGIN
2081 tmpValue := '';
2082 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
2083
2084 assertEqualsAnsiString('testAnsiTrimLeftChars_Empty', '', tmpResult);
2085 END;
2086
2087
2088 PROCEDURE testAnsiTrimLeftChars_RemoveAll;
2089 VAR
2090 tmpResult : AnsiString;
2091 tmpValue : AnsiString;
2092 BEGIN
2093 tmpValue := 'bxxxbx';
2094 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
2095
2096 assertEqualsAnsiString('testAnsiTrimLeftChars_RemoveAll', '', tmpResult);
2097 END;
2098
2099
2100 PROCEDURE testAnsiTrimLeftChars_OneLeft;
2101 VAR
2102 tmpResult : AnsiString;
2103 tmpValue : AnsiString;
2104 BEGIN
2105 tmpValue := 'bxy';
2106 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
2107
2108 assertEqualsAnsiString('testAnsiTrimLeftChars_OneLeft', 'y', tmpResult);
2109 END;
2110
2111
2112 PROCEDURE testAnsiTrimLeftChars_LeftOnly;
2113 VAR
2114 tmpResult : AnsiString;
2115 tmpValue : AnsiString;
2116 BEGIN
2117 tmpValue := 'bxbxxay';
2118 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
2119
2120 assertEqualsAnsiString('testAnsiTrimLeftChars_LeftOnly', 'ay', tmpResult);
2121 END;
2122
2123
2124 PROCEDURE testAnsiTrimLeftChars_CharsInside;
2125 VAR
2126 tmpResult : AnsiString;
2127 tmpValue : AnsiString;
2128 BEGIN
2129 tmpValue := 'bxabxvvx';
2130 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
2131
2132 assertEqualsAnsiString('testAnsiTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
2133 END;
2134
2135
2136 PROCEDURE testAnsiTrimLeftChars_Nothing;
2137 VAR
2138 tmpResult : AnsiString;
2139 tmpValue : AnsiString;
2140 BEGIN
2141 tmpValue := 'acdef';
2142 tmpResult := AnsiStrTrimLeftChars('acdef', ['b', 'x']);
2143
2144 assertEqualsAnsiString('testAnsiTrimLeftChars_Nothing', 'acdef', tmpResult);
2145 END;
2146
2147
2148 PROCEDURE testAnsiTrimLeftChars_ReallyLong;
2149 VAR
2150 tmpResult : AnsiString;
2151 tmpValue : AnsiString;
2152 BEGIN
2153 tmpValue := '0123456789';
2154 tmpValue := tmpValue + tmpValue;
2155 tmpValue := tmpValue + tmpValue;
2156 tmpValue := tmpValue + tmpValue;
2157 tmpValue := tmpValue + tmpValue;
2158 tmpValue := tmpValue + tmpValue;
2159 assertEqualsInt('testAnsiTrimLeftChars_ReallyLong', 320, Length(tmpValue));
2160
2161 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['0', '1']);
2162
2163 assertEqualsInt('testAnsiTrimLeftChars_ReallyLong', 318, Length(tmpResult));
2164 END;
2165
2166
2167 // -------------------------------------------------------------------
2168
2169
2170 PROCEDURE testAnsiTrimRightChars_Empty;
2171 VAR
2172 tmpResult : AnsiString;
2173 tmpValue : AnsiString;
2174 BEGIN
2175 tmpValue := '';
2176 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
2177
2178 assertEqualsAnsiString('testAnsiTrimRightChars_Empty', '', tmpResult);
2179 END;
2180
2181
2182 PROCEDURE testAnsiTrimRightChars_RemoveAll;
2183 VAR
2184 tmpResult : AnsiString;
2185 tmpValue : AnsiString;
2186 BEGIN
2187 tmpValue := 'bxxxbx';
2188 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
2189
2190 assertEqualsAnsiString('testAnsiTrimRightChars_RemoveAll', '', tmpResult);
2191 END;
2192
2193
2194 PROCEDURE testAnsiTrimRightChars_OneLeft;
2195 VAR
2196 tmpResult : AnsiString;
2197 tmpValue : AnsiString;
2198 BEGIN
2199 tmpValue := 'ybx';
2200 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
2201
2202 assertEqualsAnsiString('testAnsiTrimRightChars_OneLeft', 'y', tmpResult);
2203 END;
2204
2205
2206 PROCEDURE testAnsiTrimRightChars_RightOnly;
2207 VAR
2208 tmpResult : AnsiString;
2209 tmpValue : AnsiString;
2210 BEGIN
2211 tmpValue := 'aybxbxx';
2212 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
2213
2214 assertEqualsAnsiString('testAnsiTrimRightChars_RightOnly', 'ay', tmpResult);
2215 END;
2216
2217
2218 PROCEDURE testAnsiTrimRightChars_CharsInside;
2219 VAR
2220 tmpResult : AnsiString;
2221 tmpValue : AnsiString;
2222 BEGIN
2223 tmpValue := 'abxvvxb';
2224 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
2225
2226 assertEqualsAnsiString('testAnsiTrimRightChars_CharsInside', 'abxvv', tmpResult);
2227 END;
2228
2229
2230 PROCEDURE testAnsiTrimRightChars_Nothing;
2231 VAR
2232 tmpResult : AnsiString;
2233 tmpValue : AnsiString;
2234 BEGIN
2235 tmpValue := 'acdef';
2236 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
2237
2238 assertEqualsAnsiString('testAnsiTrimRightChars_Nothing', 'acdef', tmpResult);
2239 END;
2240
2241
2242 PROCEDURE testAnsiTrimRightChars_ReallyLong;
2243 VAR
2244 tmpResult : AnsiString;
2245 tmpValue : AnsiString;
2246 BEGIN
2247 tmpValue := '0123456789';
2248 tmpValue := tmpValue + tmpValue;
2249 tmpValue := tmpValue + tmpValue;
2250 tmpValue := tmpValue + tmpValue;
2251 tmpValue := tmpValue + tmpValue;
2252 tmpValue := tmpValue + tmpValue;
2253 assertEqualsInt('testAnsiTrimRightChars_ReallyLong', 320, Length(tmpValue));
2254
2255 tmpResult := AnsiStrTrimRightChars(tmpValue, ['8', '9']);
2256
2257 assertEqualsInt('testAnsiTrimRightChars_ReallyLong', 318, Length(tmpResult));
2258 END;
2259
2260
2261 // -------------------------------------------------------------------
2262
2263 PROCEDURE testAnsiTrimChars_Empty;
2264 VAR
2265 tmpResult : AnsiString;
2266 tmpValue : AnsiString;
2267 BEGIN
2268 tmpValue := '';
2269 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2270
2271 assertEqualsAnsiString('testAnsiTrimChars_Empty', '', tmpResult);
2272 END;
2273
2274
2275 PROCEDURE testAnsiTrimChars_RemoveAll;
2276 VAR
2277 tmpResult : AnsiString;
2278 tmpValue : AnsiString;
2279 BEGIN
2280 tmpValue := 'bxxxbx';
2281 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2282
2283 assertEqualsAnsiString('testAnsiTrimChars_RemoveAll', '', tmpResult);
2284 END;
2285
2286
2287 PROCEDURE testAnsiTrimChars_OneLeftFromLeft;
2288 VAR
2289 tmpResult : AnsiString;
2290 tmpValue : AnsiString;
2291 BEGIN
2292 tmpValue := 'bxa';
2293 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2294
2295 assertEqualsAnsiString('testAnsiTrimChars_OneLeftFromLeft', 'a', tmpResult);
2296 END;
2297
2298
2299 PROCEDURE testAnsiTrimChars_OneLeftFromRight;
2300 VAR
2301 tmpResult : AnsiString;
2302 tmpValue : AnsiString;
2303 BEGIN
2304 tmpValue := 'abx';
2305 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2306
2307 assertEqualsAnsiString('testAnsiTrimChars_OneLeftFromRight', 'a', tmpResult);
2308 END;
2309
2310
2311 PROCEDURE testAnsiTrimChars_LeftOnly;
2312 VAR
2313 tmpResult : AnsiString;
2314 tmpValue : AnsiString;
2315 BEGIN
2316 tmpValue := 'bxbxxay';
2317 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2318
2319 assertEqualsAnsiString('testAnsiTrimChars_LeftOnly', 'ay', tmpResult);
2320 END;
2321
2322
2323 PROCEDURE testAnsiTrimChars_RightOnly;
2324 VAR
2325 tmpResult : AnsiString;
2326 tmpValue : AnsiString;
2327 BEGIN
2328 tmpValue := 'aybxbxx';
2329 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2330
2331 assertEqualsAnsiString('testAnsiTrimChars_LeftOnly', 'ay', tmpResult);
2332 END;
2333
2334
2335 PROCEDURE testAnsiTrimChars_CharsInside;
2336 VAR
2337 tmpResult : AnsiString;
2338 tmpValue : AnsiString;
2339 BEGIN
2340 tmpValue := 'bxabxvvx';
2341 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2342
2343 assertEqualsAnsiString('testAnsiTrimChars_CharsInside', 'abxvv', tmpResult);
2344 END;
2345
2346
2347 PROCEDURE testAnsiTrimChars_Nothing;
2348 VAR
2349 tmpResult : AnsiString;
2350 tmpValue : AnsiString;
2351 BEGIN
2352 tmpValue := 'acdef';
2353 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2354
2355 assertEqualsAnsiString('testAnsiTrimChars_Nothing', 'acdef', tmpResult);
2356 END;
2357
2358
2359 PROCEDURE testAnsiTrimChars_ReallyLong;
2360 VAR
2361 tmpResult : AnsiString;
2362 tmpValue : AnsiString;
2363 BEGIN
2364 tmpValue := '0123456789';
2365 tmpValue := tmpValue + tmpValue;
2366 tmpValue := tmpValue + tmpValue;
2367 tmpValue := tmpValue + tmpValue;
2368 tmpValue := tmpValue + tmpValue;
2369 tmpValue := tmpValue + tmpValue;
2370 assertEqualsInt('testAnsiTrimChars_ReallyLong', 320, Length(tmpValue));
2371
2372 tmpResult := AnsiStrTrimChars(tmpValue, ['8', '9', '0', '1']);
2373
2374 assertEqualsInt('testAnsiTrimChars_ReallyLong', 316, Length(tmpResult));
2375 END;
2376
2377
2378 // -------------------------------------------------------------------
2379
2380
2381 PROCEDURE testAnsiTrim;
2382 VAR
2383 tmpResult : String;
2384 tmpValue : AnsiString;
2385 BEGIN
2386 tmpValue := ' a bc ';
2387 tmpResult := AnsiStrTrim(tmpValue);
2388
2389 assertEqualsAnsiString('testAnsiTrim', 'a bc', tmpResult);
2390 END;
2391
2392
2393 PROCEDURE testAnsiTrim_ReallyLong;
2394 VAR
2395 tmpResult : AnsiString;
2396 tmpValue : AnsiString;
2397 BEGIN
2398 tmpValue := '0123456789';
2399 tmpValue := tmpValue + tmpValue;
2400 tmpValue := tmpValue + tmpValue;
2401 tmpValue := tmpValue + tmpValue;
2402 tmpValue := tmpValue + tmpValue;
2403 tmpValue := tmpValue + tmpValue;
2404 tmpValue := ' ' + tmpValue + ' ';
2405 assertEqualsInt('testAnsiTrim_ReallyLong', 326, Length(tmpValue));
2406
2407 tmpResult := AnsiStrTrim(tmpValue);
2408
2409 assertEqualsInt('testAnsiTrim_ReallyLong', 320, Length(tmpResult));
2410 END;
2411
2412
2413 // -------------------------------------------------------------------
2414
2415
[35]2416 FUNCTION getStringUtilsUnitTests : TList;
2417 BEGIN
2418 result := TList.Create;
2419
2420 result.add(@testTSerializableStringList_Construction);
2421 result.add(@testTSerializableStringList_Add);
2422 result.add(@testTSerializableStringList_Get_Empty);
2423 result.add(@testTSerializableStringList_Get);
2424 result.add(@testTSerializableStringList_getSerializedString_Empty);
2425 result.add(@testTSerializableStringList_getSerializedString);
2426 result.add(@testTSerializableStringList_getSerializedString);
2427 result.add(@testTSerializableStringList_getSerializedString_WithBlanks);
2428 result.add(@testTSerializableStringList_getSerializedString_Escaping);
2429 result.add(@testTSerializableStringList_readValuesFromSerializedString);
2430 result.add(@testTSerializableStringList_readValuesFromSerializedString_quoted);
2431 result.add(@testTSerializableStringList_readValuesFromSerializedString_empty);
2432 result.add(@testTSerializableStringList_readValuesFromSerializedString_firstempty);
2433 result.add(@testTSerializableStringList_readValuesFromSerializedString_2);
2434
2435 result.add(@testEscapeAllCharsBy);
2436 result.add(@testEscapeAllCharsBy_Empty);
2437 result.add(@testEscapeAllCharsBy_EmptyChars);
2438 result.add(@testEscapeAllCharsBy_EscapeEscape);
[139]2439 result.add(@testEscapeAllCharsBy_NoCharactersToEscape);
2440 result.add(@testEscapeAllCharsBy_DoubleDoubleQuotes);
[41]2441
2442 result.add(@testStrExtractStrings_EmptyReceiver);
2443 result.add(@testStrExtractStrings_OnlyOnePart);
2444 result.add(@testStrExtractStrings_ManyParts);
2445 result.add(@testStrExtractStrings_StartWithDelimiter);
2446 result.add(@testStrExtractStrings_EndWithDelimiter);
2447 result.add(@testStrExtractStrings_EmptyPartInside);
2448 result.add(@testStrExtractStrings_NoDelimiter);
2449 result.add(@testStrExtractStrings_EscapedDelimiter);
2450 result.add(@testStrExtractStrings_EscapedEscapeChar);
[105]2451 result.add(@testStrExtractStrings_DelimiterSameAsEscapeChar);
[41]2452
[82]2453 result.add(@testStrExtractStringsIgnoreEmpty_EmptyReceiver);
2454 result.add(@testStrExtractStringsIgnoreEmpty_OnlyOnePart);
2455 result.add(@testStrExtractStringsIgnoreEmpty_ManyParts);
2456 result.add(@testStrExtractStringsIgnoreEmpty_StartWithDelimiter);
2457 result.add(@testStrExtractStringsIgnoreEmpty_EndWithDelimiter);
2458 result.add(@testStrExtractStringsIgnoreEmpty_EmptyPartInside);
2459 result.add(@testStrExtractStringsIgnoreEmpty_NoDelimiter);
2460 result.add(@testStrExtractStringsIgnoreEmpty_EscapedDelimiter);
2461 result.add(@testStrExtractStringsIgnoreEmpty_EscapedEscapeChar);
2462
2463 result.add(@testTrimLeftChars_Empty);
2464 result.add(@testTrimLeftChars_RemoveAll);
2465 result.add(@testTrimLeftChars_OneLeft);
2466 result.add(@testTrimLeftChars_LeftOnly);
2467 result.add(@testTrimLeftChars_CharsInside);
2468 result.add(@testTrimLeftChars_Nothing);
2469
2470 result.add(@testTrimRightChars_Empty);
2471 result.add(@testTrimRightChars_RemoveAll);
2472 result.add(@testTrimRightChars_OneLeft);
2473 result.add(@testTrimRightChars_RightOnly);
2474 result.add(@testTrimRightChars_CharsInside);
2475 result.add(@testTrimRightChars_Nothing);
2476
[41]2477 result.add(@testTrimChars_Empty);
2478 result.add(@testTrimChars_RemoveAll);
[82]2479 result.add(@testTrimChars_OneLeftFromLeft);
2480 result.add(@testTrimChars_OneLeftFromRight);
[41]2481 result.add(@testTrimChars_LeftOnly);
2482 result.add(@testTrimChars_RightOnly);
2483 result.add(@testTrimChars_CharsInside);
2484 result.add(@testTrimChars_Nothing);
[82]2485
[41]2486 result.add(@testTrim);
2487
[82]2488 result.add(@testStrLeft_Empty);
2489 result.add(@testStrLeft_Nothing);
2490 result.add(@testStrLeft_WholeString);
2491 result.add(@testStrLeft_ToManyRequested);
2492 result.add(@testStrLeft_Part);
2493
[102]2494 result.add(@testStrLeftWithout_Empty);
2495 result.add(@testStrLeftWithout_ToBig);
2496 result.add(@testStrLeftWithout_Negative);
2497 result.add(@testStrLeftWithout_All);
2498 result.add(@testStrLeftWithout);
2499
2500 result.add(@testStrLeftUntil_Empty);
2501 result.add(@testStrLeftUntil_Empty_EmptyDelimiterSet);
2502 result.add(@testStrLeftUntil_EmptyDelimiterSet);
2503 result.add(@testStrLeftUntil_FirstIsDelimiter);
2504 result.add(@testStrLeftUntil_LastIsDelimiter);
2505 result.add(@testStrLeftUntil_UnusedDelimiter);
2506 result.add(@testStrLeftUntil);
2507
[118]2508 result.add(@testStrSubstringFrom_Empty);
2509 result.add(@testStrSubstringFrom_EmptyZeroPos);
2510 result.add(@testStrSubstringFrom_EmptyNegativePos);
2511 result.add(@testStrSubstringFrom_FullCopy);
2512 result.add(@testStrSubstringFrom_ZeroPos);
2513 result.add(@testStrSubstringFrom_NegativePos);
2514 result.add(@testStrSubstringFrom_ToBigPos);
2515 result.add(@testStrSubstringFrom);
2516
[102]2517 result.add(@testStrStartsWith_BothEmpty);
2518 result.add(@testStrStartsWith_StringEmpty);
2519 result.add(@testStrStartsWith_MatchEmpty);
2520 result.add(@testStrStartsWith_StringToShort);
2521 result.add(@testStrStartsWith_StringEqualLength);
2522 result.add(@testStrStartsWith_StringEqualLengthMatch);
2523 result.add(@testStrStartsWith_StringMatch);
2524 result.add(@testStrStartsWith_StringMatchCaseSensitive);
2525
2526 result.add(@testStrStartsWithIgnoringCase_BothEmpty);
2527 result.add(@testStrStartsWithIgnoringCase_StringEmpty);
2528 result.add(@testStrStartsWithIgnoringCase_MatchEmpty);
2529 result.add(@testStrStartsWithIgnoringCase_StringToShort);
2530 result.add(@testStrStartsWithIgnoringCase_StringEqualLength);
2531 result.add(@testStrStartsWithIgnoringCase_StringEqualLengthMatch);
2532 result.add(@testStrStartsWithIgnoringCase_StringMatch);
2533 result.add(@testStrStartsWithIgnoringCase_StringMatchCaseInSensitive);
2534
[41]2535 result.add(@testStrEndsWith_BothEmpty);
2536 result.add(@testStrEndsWith_StringEmpty);
2537 result.add(@testStrEndsWith_MatchEmpty);
2538 result.add(@testStrEndsWith_StringToShort);
2539 result.add(@testStrEndsWith_StringEqualLength);
2540 result.add(@testStrEndsWith_StringEqualLengthMatch);
2541 result.add(@testStrEndsWith_StringMatch);
2542 result.add(@testStrEndsWith_StringMatchCaseSensitive);
2543
2544 result.add(@testStrEndsWithIgnoringCase_BothEmpty);
2545 result.add(@testStrEndsWithIgnoringCase_StringEmpty);
2546 result.add(@testStrEndsWithIgnoringCase_MatchEmpty);
2547 result.add(@testStrEndsWithIgnoringCase_StringToShort);
2548 result.add(@testStrEndsWithIgnoringCase_StringEqualLength);
2549 result.add(@testStrEndsWithIgnoringCase_StringEqualLengthMatch);
2550 result.add(@testStrEndsWithIgnoringCase_StringMatch);
2551 result.add(@testStrEndsWithIgnoringCase_StringMatchCaseInSensitive);
2552
[139]2553 result.add(@testStrIsEmptyOrSpaces_Empty);
2554 result.add(@testStrIsEmptyOrSpaces_OneSpace);
2555 result.add(@testStrIsEmptyOrSpaces_ManySpaces);
2556 result.add(@testStrIsEmptyOrSpaces_OneChar);
2557 result.add(@testStrIsEmptyOrSpaces_ManyChars);
2558 result.add(@testStrIsEmptyOrSpaces_SpacesWithOneChar);
2559 result.add(@testStrIsEmptyOrSpaces_CharZero);
2560
[105]2561 result.add(@testStrEqualIgnoringCase_BothEmpty);
2562 result.add(@testStrEqualIgnoringCase_FirstEmpty);
2563 result.add(@testStrEqualIgnoringCase_SecondEmpty);
2564 result.add(@testStrEqualIgnoringCase_DifferentLength);
2565 result.add(@testStrEqualIgnoringCase_DifferentCase);
2566 result.add(@testStrEqualIgnoringCase);
2567
[68]2568 result.add(@testLongWordToStr_Zero);
2569 result.add(@testLongWordToStr_Four);
2570 result.add(@testLongWordToStr_Max);
2571
[65]2572 result.add(@testBoolToStr_true);
2573 result.add(@testBoolToStr_false);
[102]2574
[139]2575 result.add(@testStrInSingleQuotes_Empty);
2576 result.add(@testStrInSingleQuotes);
2577
[102]2578 result.add(@testStrInDoubleQuotes_Empty);
2579 result.add(@testStrInDoubleQuotes);
[106]2580
2581 result.add(@testStrExtractStringsQuoted_Empty);
2582 result.add(@testStrExtractStringsQuoted_OnlyWhitespace);
2583 result.add(@testStrExtractStringsQuoted_OnlyText);
2584 result.add(@testStrExtractStringsQuoted_OnlyText2Parts);
2585 result.add(@testStrExtractStringsQuoted_TextAndWhitespace2Parts);
2586 result.add(@testStrExtractStringsQuoted_QuotedText1Part);
2587 result.add(@testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes);
2588 result.add(@testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace);
2589 result.add(@testStrExtractStringsQuoted_QuotedText1PartQuoteInside);
2590 result.add(@testStrExtractStringsQuoted_QuotedText1Part2QuotesInside);
2591 result.add(@testStrExtractStringsQuoted_QuotedText1Part2Quotes);
2592 result.add(@testStrExtractStringsQuoted_Only1Quote);
2593 result.add(@testStrExtractStringsQuoted_Only1QuoteAndWhitespace);
2594 result.add(@testStrExtractStringsQuoted_QuoteStartsNewPart);
2595 result.add(@testStrExtractStringsQuoted_ManyParts);
2596
[110]2597 result.add(@testCaseInsensitivePos_Empty);
2598 result.add(@testCaseInsensitivePos_EmptyPart);
2599 result.add(@testCaseInsensitivePos_EmptyString);
2600 result.add(@testCaseInsensitivePos_PartLarger);
2601 result.add(@testCaseInsensitivePos_AtLeft);
2602 result.add(@testCaseInsensitivePos_Middle);
2603 result.add(@testCaseInsensitivePos_AtRight);
2604 result.add(@testCaseInsensitivePos);
2605
[139]2606 result.add(@testLastPosOfChar_Empty);
2607 result.add(@testLastPosOfChar_NotFound);
2608 result.add(@testLastPosOfChar_OneCharNotFound);
2609 result.add(@testLastPosOfChar_OneCharFound);
2610 result.add(@testLastPosOfChar_OneCharWrongCase);
2611 result.add(@testLastPosOfChar_FirstChar);
2612 result.add(@testLastPosOfChar_LastChar);
2613 result.add(@testLastPosOfChar_MiddleChar);
2614 result.add(@testLastPosOfChar_ManyHits);
2615
2616
[110]2617 // --------------------
2618 // ---- AnsiString ----
2619 // --------------------
2620
2621
2622 result.add(@testAnsiTrimLeftChars_Empty);
2623 result.add(@testAnsiTrimLeftChars_RemoveAll);
2624 result.add(@testAnsiTrimLeftChars_OneLeft);
2625 result.add(@testAnsiTrimLeftChars_LeftOnly);
2626 result.add(@testAnsiTrimLeftChars_CharsInside);
2627 result.add(@testAnsiTrimLeftChars_Nothing);
2628 result.add(@testAnsiTrimLeftChars_ReallyLong);
2629
2630 result.add(@testAnsiTrimRightChars_Empty);
2631 result.add(@testAnsiTrimRightChars_RemoveAll);
2632 result.add(@testAnsiTrimRightChars_OneLeft);
2633 result.add(@testAnsiTrimRightChars_RightOnly);
2634 result.add(@testAnsiTrimRightChars_CharsInside);
2635 result.add(@testAnsiTrimRightChars_Nothing);
2636 result.add(@testAnsiTrimRightChars_ReallyLong);
2637
2638 result.add(@testAnsiTrimChars_Empty);
2639 result.add(@testAnsiTrimChars_RemoveAll);
2640 result.add(@testAnsiTrimChars_OneLeftFromLeft);
2641 result.add(@testAnsiTrimChars_OneLeftFromRight);
2642 result.add(@testAnsiTrimChars_LeftOnly);
2643 result.add(@testAnsiTrimChars_RightOnly);
2644 result.add(@testAnsiTrimChars_CharsInside);
2645 result.add(@testAnsiTrimChars_Nothing);
2646 result.add(@testAnsiTrimChars_ReallyLong);
2647
2648 result.add(@testAnsiTrim);
2649 result.add(@testAnsiTrim_ReallyLong);
2650
2651
[35]2652 END;
2653
[384]2654END.
Note: See TracBrowser for help on using the repository browser.