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

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

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