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

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

AnsiString functins added
  • Property svn:eol-style set to native
File size: 61.8 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 testStrStartsWith_BothEmpty;
959 VAR
960 tmpResult : Boolean;
961 BEGIN
962 tmpResult := StrStartsWith('', '');
963
964 assertTrue('testStrStartsWith_BothEmpty', tmpResult);
965 END;
966
967
968 PROCEDURE testStrStartsWith_StringEmpty;
969 VAR
970 tmpResult : Boolean;
971 BEGIN
972 tmpResult := StrStartsWith('', 'end');
973
974 assertFalse('testStrStartsWith_StringEmpty', tmpResult);
975 END;
976
977
978 PROCEDURE testStrStartsWith_MatchEmpty;
979 VAR
980 tmpResult : Boolean;
981 BEGIN
982 tmpResult := StrStartsWith('test', '');
983
984 assertTrue('testStrStartsWith_MatchEmpty', tmpResult);
985 END;
986
987
988 PROCEDURE testStrStartsWith_StringToShort;
989 VAR
990 tmpResult : Boolean;
991 BEGIN
992 tmpResult := StrStartsWith('test', 'test1');
993
994 assertFalse('testStrStartsWith_StringToShort', tmpResult);
995 END;
996
997
998 PROCEDURE testStrStartsWith_StringEqualLength;
999 VAR
1000 tmpResult : Boolean;
1001 BEGIN
1002 tmpResult := StrStartsWith('test', 'best');
1003
1004 assertFalse('testStrStartsWith_StringEqualLength', tmpResult);
1005 END;
1006
1007
1008 PROCEDURE testStrStartsWith_StringEqualLengthMatch;
1009 VAR
1010 tmpResult : Boolean;
1011 BEGIN
1012 tmpResult := StrStartsWith('test', 'test');
1013
1014 assertTrue('testStrStartsWith_StringEqualLengthMatch', tmpResult);
1015 END;
1016
1017
1018 PROCEDURE testStrStartsWith_StringMatch;
1019 VAR
1020 tmpResult : Boolean;
1021 BEGIN
1022 tmpResult := StrStartsWith('this is a simple test', 'this');
1023
1024 assertTrue('testStrStartsWith_StringMatch', tmpResult);
1025 END;
1026
1027
1028 PROCEDURE testStrStartsWith_StringMatchCaseSensitive;
1029 VAR
1030 tmpResult : Boolean;
1031 BEGIN
1032 tmpResult := StrStartsWith('This is a simple test', 'tHis');
1033
1034 assertFalse('testStrStartsWith_StringMatchCaseSensitive', tmpResult);
1035 END;
1036
1037
1038 // -------------------------------------------------------------------
1039
1040
1041 PROCEDURE testStrStartsWithIgnoringCase_BothEmpty;
1042 VAR
1043 tmpResult : Boolean;
1044 BEGIN
1045 tmpResult := StrStartsWithIgnoringCase('', '');
1046
1047 assertTrue('testStrStartsWithIgnoringCase_BothEmpty', tmpResult);
1048 END;
1049
1050
1051 PROCEDURE testStrStartsWithIgnoringCase_StringEmpty;
1052 VAR
1053 tmpResult : Boolean;
1054 BEGIN
1055 tmpResult := StrStartsWithIgnoringCase('', 'end');
1056
1057 assertFalse('testStrStartsWithIgnoringCase_StringEmpty', tmpResult);
1058 END;
1059
1060
1061 PROCEDURE testStrStartsWithIgnoringCase_MatchEmpty;
1062 VAR
1063 tmpResult : Boolean;
1064 BEGIN
1065 tmpResult := StrStartsWithIgnoringCase('test', '');
1066
1067 assertTrue('testStrStartsWithIgnoringCase_MatchEmpty', tmpResult);
1068 END;
1069
1070
1071 PROCEDURE testStrStartsWithIgnoringCase_StringToShort;
1072 VAR
1073 tmpResult : Boolean;
1074 BEGIN
1075 tmpResult := StrStartsWithIgnoringCase('test', 'test1');
1076
1077 assertFalse('testStrStartsWithIgnoringCase_StringToShort', tmpResult);
1078 END;
1079
1080
1081 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLength;
1082 VAR
1083 tmpResult : Boolean;
1084 BEGIN
1085 tmpResult := StrStartsWithIgnoringCase('test', 'best');
1086
1087 assertFalse('testStrStartsWithIgnoringCase_StringEqualLength', tmpResult);
1088 END;
1089
1090
1091 PROCEDURE testStrStartsWithIgnoringCase_StringEqualLengthMatch;
1092 VAR
1093 tmpResult : Boolean;
1094 BEGIN
1095 tmpResult := StrStartsWithIgnoringCase('test', 'test');
1096
1097 assertTrue('testStrStartsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1098 END;
1099
1100
1101 PROCEDURE testStrStartsWithIgnoringCase_StringMatch;
1102 VAR
1103 tmpResult : Boolean;
1104 BEGIN
1105 tmpResult := StrStartsWithIgnoringCase('This is a simple test', 'This');
1106
1107 assertTrue('testStrStartsWithIgnoringCase_StringMatch', tmpResult);
1108 END;
1109
1110
1111 PROCEDURE testStrStartsWithIgnoringCase_StringMatchCaseInSensitive;
1112 VAR
1113 tmpResult : Boolean;
1114 BEGIN
1115 tmpResult := StrStartsWithIgnoringCase('ThiS is a simple test', 'THis');
1116
1117 assertTrue('testStrStartsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1118 END;
1119
1120
1121 // -------------------------------------------------------------------
1122
1123
1124 PROCEDURE testStrEndsWith_BothEmpty;
1125 VAR
1126 tmpResult : Boolean;
1127 BEGIN
1128 tmpResult := StrEndsWith('', '');
1129
1130 assertTrue('testStrEndsWith_BothEmpty', tmpResult);
1131 END;
1132
1133
1134 PROCEDURE testStrEndsWith_StringEmpty;
1135 VAR
1136 tmpResult : Boolean;
1137 BEGIN
1138 tmpResult := StrEndsWith('', 'end');
1139
1140 assertFalse('testStrEndsWith_StringEmpty', tmpResult);
1141 END;
1142
1143
1144 PROCEDURE testStrEndsWith_MatchEmpty;
1145 VAR
1146 tmpResult : Boolean;
1147 BEGIN
1148 tmpResult := StrEndsWith('test', '');
1149
1150 assertTrue('testStrEndsWith_MatchEmpty', tmpResult);
1151 END;
1152
1153
1154 PROCEDURE testStrEndsWith_StringToShort;
1155 VAR
1156 tmpResult : Boolean;
1157 BEGIN
1158 tmpResult := StrEndsWith('test', 'test1');
1159
1160 assertFalse('testStrEndsWith_StringToShort', tmpResult);
1161 END;
1162
1163
1164 PROCEDURE testStrEndsWith_StringEqualLength;
1165 VAR
1166 tmpResult : Boolean;
1167 BEGIN
1168 tmpResult := StrEndsWith('test', 'best');
1169
1170 assertFalse('testStrEndsWith_StringEqualLength', tmpResult);
1171 END;
1172
1173
1174 PROCEDURE testStrEndsWith_StringEqualLengthMatch;
1175 VAR
1176 tmpResult : Boolean;
1177 BEGIN
1178 tmpResult := StrEndsWith('test', 'test');
1179
1180 assertTrue('testStrEndsWith_StringEqualLengthMatch', tmpResult);
1181 END;
1182
1183
1184 PROCEDURE testStrEndsWith_StringMatch;
1185 VAR
1186 tmpResult : Boolean;
1187 BEGIN
1188 tmpResult := StrEndsWith('a simple test', 'test');
1189
1190 assertTrue('testStrEndsWith_StringMatch', tmpResult);
1191 END;
1192
1193
1194 PROCEDURE testStrEndsWith_StringMatchCaseSensitive;
1195 VAR
1196 tmpResult : Boolean;
1197 BEGIN
1198 tmpResult := StrEndsWith('a simple tEst', 'test');
1199
1200 assertFalse('testStrEndsWith_StringMatchCaseSensitive', tmpResult);
1201 END;
1202
1203
1204 PROCEDURE testStrEndsWithIgnoringCase_BothEmpty;
1205 VAR
1206 tmpResult : Boolean;
1207 BEGIN
1208 tmpResult := StrEndsWithIgnoringCase('', '');
1209
1210 assertTrue('testStrEndsWithIgnoringCase_BothEmpty', tmpResult);
1211 END;
1212
1213
1214 PROCEDURE testStrEndsWithIgnoringCase_StringEmpty;
1215 VAR
1216 tmpResult : Boolean;
1217 BEGIN
1218 tmpResult := StrEndsWithIgnoringCase('', 'end');
1219
1220 assertFalse('testStrEndsWithIgnoringCase_StringEmpty', tmpResult);
1221 END;
1222
1223
1224 PROCEDURE testStrEndsWithIgnoringCase_MatchEmpty;
1225 VAR
1226 tmpResult : Boolean;
1227 BEGIN
1228 tmpResult := StrEndsWithIgnoringCase('test', '');
1229
1230 assertTrue('testStrEndsWithIgnoringCase_MatchEmpty', tmpResult);
1231 END;
1232
1233
1234 PROCEDURE testStrEndsWithIgnoringCase_StringToShort;
1235 VAR
1236 tmpResult : Boolean;
1237 BEGIN
1238 tmpResult := StrEndsWithIgnoringCase('test', 'test1');
1239
1240 assertFalse('testStrEndsWithIgnoringCase_StringToShort', tmpResult);
1241 END;
1242
1243
1244 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLength;
1245 VAR
1246 tmpResult : Boolean;
1247 BEGIN
1248 tmpResult := StrEndsWithIgnoringCase('test', 'best');
1249
1250 assertFalse('testStrEndsWithIgnoringCase_StringEqualLength', tmpResult);
1251 END;
1252
1253
1254 PROCEDURE testStrEndsWithIgnoringCase_StringEqualLengthMatch;
1255 VAR
1256 tmpResult : Boolean;
1257 BEGIN
1258 tmpResult := StrEndsWithIgnoringCase('test', 'test');
1259
1260 assertTrue('testStrEndsWithIgnoringCase_StringEqualLengthMatch', tmpResult);
1261 END;
1262
1263
1264 PROCEDURE testStrEndsWithIgnoringCase_StringMatch;
1265 VAR
1266 tmpResult : Boolean;
1267 BEGIN
1268 tmpResult := StrEndsWithIgnoringCase('a simple test', 'test');
1269
1270 assertTrue('testStrEndsWithIgnoringCase_StringMatch', tmpResult);
1271 END;
1272
1273
1274 PROCEDURE testStrEndsWithIgnoringCase_StringMatchCaseInSensitive;
1275 VAR
1276 tmpResult : Boolean;
1277 BEGIN
1278 tmpResult := StrEndsWithIgnoringCase('a simple tEst', 'test');
1279
1280 assertTrue('testStrEndsWithIgnoringCase_StringMatchCaseSensitive', tmpResult);
1281 END;
1282
1283
1284 // ----------------------------------------------------------
1285
1286
1287 PROCEDURE testStrEqualIgnoringCase_BothEmpty;
1288 VAR
1289 tmpResult : Boolean;
1290 BEGIN
1291 tmpResult := StrEqualIgnoringCase('', '');
1292
1293 assertTrue('testStrEqualIgnoringCase_BothEmpty', tmpResult);
1294 END;
1295
1296
1297 PROCEDURE testStrEqualIgnoringCase_FirstEmpty;
1298 VAR
1299 tmpResult : Boolean;
1300 BEGIN
1301 tmpResult := StrEqualIgnoringCase('', 'xy');
1302
1303 assertFalse('testStrEqualIgnoringCase_FirstEmpty', tmpResult);
1304 END;
1305
1306 PROCEDURE testStrEqualIgnoringCase_SecondEmpty;
1307 VAR
1308 tmpResult : Boolean;
1309 BEGIN
1310 tmpResult := StrEqualIgnoringCase('xy', '');
1311
1312 assertFalse('testStrEqualIgnoringCase_SecondEmpty', tmpResult);
1313 END;
1314
1315 PROCEDURE testStrEqualIgnoringCase_DifferentLength;
1316 VAR
1317 tmpResult : Boolean;
1318 BEGIN
1319 tmpResult := StrEqualIgnoringCase('xy', 'xyz');
1320
1321 assertFalse('testStrEqualIgnoringCase_DifferentLength', tmpResult);
1322 END;
1323
1324 PROCEDURE testStrEqualIgnoringCase_DifferentCase;
1325 VAR
1326 tmpResult : Boolean;
1327 BEGIN
1328 tmpResult := StrEqualIgnoringCase('xYz', 'xyz');
1329
1330 assertTrue('testStrEqualIgnoringCase_DifferentCase', tmpResult);
1331 END;
1332
1333 PROCEDURE testStrEqualIgnoringCase;
1334 VAR
1335 tmpResult : Boolean;
1336 BEGIN
1337 tmpResult := StrEqualIgnoringCase('XYz', 'XYz');
1338
1339 assertTrue('testStrEqualIgnoringCase', tmpResult);
1340 END;
1341
1342 // ----------------------------------------------------------
1343
1344
1345 PROCEDURE testLongWordToStr_Zero;
1346 VAR
1347 tmpResult : String;
1348 BEGIN
1349 tmpResult := LongWordToStr(0);
1350
1351 assertEqualsString('testLongWordToStr_Zero', '0', tmpResult);
1352 END;
1353
1354
1355 PROCEDURE testLongWordToStr_Four;
1356 VAR
1357 tmpResult : String;
1358 BEGIN
1359 tmpResult := LongWordToStr(4);
1360
1361 assertEqualsString('testLongWordToStr_Four', '4', tmpResult);
1362 END;
1363
1364 PROCEDURE testLongWordToStr_Max;
1365 VAR
1366 tmpResult : String;
1367 BEGIN
1368 tmpResult := LongWordToStr(4294967295);
1369
1370 assertEqualsString('testLongWordToStr_Max', '4294967295', tmpResult);
1371 END;
1372
1373
1374 // ----------------------------------------------------------
1375
1376
1377 PROCEDURE testBoolToStr_true;
1378 VAR
1379 tmpResult : String;
1380 BEGIN
1381 tmpResult := BoolToStr(true);
1382
1383 assertEqualsString('testBoolToStr_true', 'True', tmpResult);
1384 END;
1385
1386
1387 PROCEDURE testBoolToStr_false;
1388 VAR
1389 tmpResult : String;
1390 BEGIN
1391 tmpResult := BoolToStr(false);
1392
1393 assertEqualsString('testBoolToStr_false', 'False', tmpResult);
1394 END;
1395
1396
1397 // ----------------------------------------------------------
1398
1399
1400 PROCEDURE testStrInDoubleQuotes_Empty;
1401 VAR
1402 tmpResult : String;
1403 BEGIN
1404 tmpResult := StrInDoubleQuotes('');
1405
1406 assertEqualsString('testStrInDoubleQuotes_Empty', '""', tmpResult);
1407 END;
1408
1409
1410 PROCEDURE testStrInDoubleQuotes;
1411 VAR
1412 tmpResult : String;
1413 BEGIN
1414 tmpResult := StrInDoubleQuotes('abc');
1415
1416 assertEqualsString('testStrInDoubleQuotes', '"abc"', tmpResult);
1417 END;
1418
1419
1420 // ----------------------------------------------------------
1421
1422
1423 PROCEDURE testStrExtractStringsQuoted_Empty;
1424 VAR
1425 tmpResult : TStringList;
1426 tmpString : String;
1427 BEGIN
1428 tmpResult := TStringList.Create;
1429 tmpString := '';
1430
1431 StrExtractStringsQuoted(tmpResult, tmpString);
1432 assertEqualsInt('testStrExtractStringsQuoted_Empty', 0, tmpResult.count);
1433
1434 tmpResult.Destroy;
1435 END;
1436
1437
1438 PROCEDURE testStrExtractStringsQuoted_OnlyWhitespace;
1439 VAR
1440 tmpResult : TStringList;
1441 tmpString : String;
1442 BEGIN
1443 tmpResult := TStringList.Create;
1444 tmpString := ' ' + StrTAB + ' ';
1445
1446 StrExtractStringsQuoted(tmpResult, tmpString);
1447 assertEqualsInt('testStrExtractStringsQuoted_OnlyWhitespace', 0, tmpResult.count);
1448
1449 tmpResult.Destroy;
1450 END;
1451
1452
1453 PROCEDURE testStrExtractStringsQuoted_OnlyText;
1454 VAR
1455 tmpResult : TStringList;
1456 tmpString : String;
1457 BEGIN
1458 tmpResult := TStringList.Create;
1459 tmpString := 'TeXt';
1460
1461 StrExtractStringsQuoted(tmpResult, tmpString);
1462 assertEqualsInt('testStrExtractStringsQuoted_OnlyText', 1, tmpResult.count);
1463 assertEqualsString('testStrExtractStringsQuoted_OnlyText', 'TeXt', tmpResult[0]);
1464
1465 tmpResult.Destroy;
1466 END;
1467
1468
1469 PROCEDURE testStrExtractStringsQuoted_OnlyText2Parts;
1470 VAR
1471 tmpResult : TStringList;
1472 tmpString : String;
1473 BEGIN
1474 tmpResult := TStringList.Create;
1475 tmpString := 'TeXt sample';
1476
1477 StrExtractStringsQuoted(tmpResult, tmpString);
1478 assertEqualsInt('testStrExtractStringsQuoted_OnlyText2Parts', 2, tmpResult.count);
1479 assertEqualsString('testStrExtractStringsQuoted_OnlyText2Parts', 'TeXt', tmpResult[0]);
1480 assertEqualsString('testStrExtractStringsQuoted_OnlyText2Parts', 'sample', tmpResult[1]);
1481
1482 tmpResult.Destroy;
1483 END;
1484
1485
1486 PROCEDURE testStrExtractStringsQuoted_TextAndWhitespace2Parts;
1487 VAR
1488 tmpResult : TStringList;
1489 tmpString : String;
1490 BEGIN
1491 tmpResult := TStringList.Create;
1492 tmpString := ' TeXt ' + StrTAB + StrTAB + ' sample ' + StrTAB;
1493
1494 StrExtractStringsQuoted(tmpResult, tmpString);
1495 assertEqualsInt('testStrExtractStringsQuoted_TextAndWhitespace2Parts', 2, tmpResult.count);
1496 assertEqualsString('testStrExtractStringsQuoted_TextAndWhitespace2Parts', 'TeXt', tmpResult[0]);
1497 assertEqualsString('testStrExtractStringsQuoted_TextAndWhitespace2Parts', 'sample', tmpResult[1]);
1498
1499 tmpResult.Destroy;
1500 END;
1501
1502
1503 PROCEDURE testStrExtractStringsQuoted_QuotedText1Part;
1504 VAR
1505 tmpResult : TStringList;
1506 tmpString : String;
1507 BEGIN
1508 tmpResult := TStringList.Create;
1509 tmpString := '"TeXt"';
1510
1511 StrExtractStringsQuoted(tmpResult, tmpString);
1512 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1Part', 1, tmpResult.count);
1513 assertEqualsString('testStrExtractStringsQuoted_QuotedText1Part', 'TeXt', tmpResult[0]);
1514
1515 tmpResult.Destroy;
1516 END;
1517
1518
1519 PROCEDURE testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes;
1520 VAR
1521 tmpResult : TStringList;
1522 tmpString : String;
1523 BEGIN
1524 tmpResult := TStringList.Create;
1525 tmpString := '"TeXt';
1526
1527 StrExtractStringsQuoted(tmpResult, tmpString);
1528 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes', 1, tmpResult.count);
1529 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes', 'TeXt', tmpResult[0]);
1530
1531 tmpResult.Destroy;
1532 END;
1533
1534
1535 PROCEDURE testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace;
1536 VAR
1537 tmpResult : TStringList;
1538 tmpString : String;
1539 BEGIN
1540 tmpResult := TStringList.Create;
1541 tmpString := '"TeX t ';
1542
1543 StrExtractStringsQuoted(tmpResult, tmpString);
1544 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace', 1, tmpResult.count);
1545 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace', 'TeX t ', tmpResult[0]);
1546
1547 tmpResult.Destroy;
1548 END;
1549
1550
1551
1552
1553 PROCEDURE testStrExtractStringsQuoted_QuotedText1PartQuoteInside;
1554 VAR
1555 tmpResult : TStringList;
1556 tmpString : String;
1557 BEGIN
1558 tmpResult := TStringList.Create;
1559 tmpString := '"TeX"t';
1560
1561 StrExtractStringsQuoted(tmpResult, tmpString);
1562 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1PartQuoteInside', 2, tmpResult.count);
1563 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartQuoteInside', 'TeX', tmpResult[0]);
1564 assertEqualsString('testStrExtractStringsQuoted_QuotedText1PartQuoteInside', 't', tmpResult[1]);
1565
1566 tmpResult.Destroy;
1567 END;
1568
1569
1570 PROCEDURE testStrExtractStringsQuoted_QuotedText1Part2QuotesInside;
1571 VAR
1572 tmpResult : TStringList;
1573 tmpString : String;
1574 BEGIN
1575 tmpResult := TStringList.Create;
1576 tmpString := '"TeX""t"';
1577
1578 StrExtractStringsQuoted(tmpResult, tmpString);
1579 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1Part2QuotesInside', 1, tmpResult.count);
1580 assertEqualsString('testStrExtractStringsQuoted_QuotedText1Part2QuotesInside', 'TeX"t', tmpResult[0]);
1581
1582 tmpResult.Destroy;
1583 END;
1584
1585
1586 PROCEDURE testStrExtractStringsQuoted_QuotedText1Part2Quotes;
1587 VAR
1588 tmpResult : TStringList;
1589 tmpString : String;
1590 BEGIN
1591 tmpResult := TStringList.Create;
1592 tmpString := '"""Te X""t"""';
1593
1594 StrExtractStringsQuoted(tmpResult, tmpString);
1595 assertEqualsInt('testStrExtractStringsQuoted_QuotedText1Part2Quotes', 1, tmpResult.count);
1596 assertEqualsString('testStrExtractStringsQuoted_QuotedText1Part2Quotes', '"Te X"t"', tmpResult[0]);
1597
1598 tmpResult.Destroy;
1599 END;
1600
1601
1602 PROCEDURE testStrExtractStringsQuoted_Only1Quote;
1603 VAR
1604 tmpResult : TStringList;
1605 tmpString : String;
1606 BEGIN
1607 tmpResult := TStringList.Create;
1608 tmpString := '"';
1609
1610 StrExtractStringsQuoted(tmpResult, tmpString);
1611 assertEqualsInt('testStrExtractStringsQuoted_Only1Quote', 0, tmpResult.count);
1612
1613 tmpResult.Destroy;
1614 END;
1615
1616
1617 PROCEDURE testStrExtractStringsQuoted_Only1QuoteAndWhitespace;
1618 VAR
1619 tmpResult : TStringList;
1620 tmpString : String;
1621 BEGIN
1622 tmpResult := TStringList.Create;
1623 tmpString := ' " ';
1624
1625 StrExtractStringsQuoted(tmpResult, tmpString);
1626 assertEqualsInt('testStrExtractStringsQuoted_Only1QuoteAndWhitespace', 1, tmpResult.count);
1627 assertEqualsString('testStrExtractStringsQuoted_Only1QuoteAndWhitespace', ' ', tmpResult[0]);
1628
1629 tmpResult.Destroy;
1630 END;
1631
1632
1633 PROCEDURE testStrExtractStringsQuoted_QuoteStartsNewPart;
1634 VAR
1635 tmpResult : TStringList;
1636 tmpString : String;
1637 BEGIN
1638 tmpResult := TStringList.Create;
1639 tmpString := 'ab"c"';
1640
1641 StrExtractStringsQuoted(tmpResult, tmpString);
1642 assertEqualsInt('testStrExtractStringsQuoted_QuoteStartsNewPart', 2, tmpResult.count);
1643 assertEqualsString('testStrExtractStringsQuoted_QuoteStartsNewPart', 'ab', tmpResult[0]);
1644 assertEqualsString('testStrExtractStringsQuoted_QuoteStartsNewPart', 'c', tmpResult[1]);
1645
1646 // note this is not compatible with the old behavior but more consistent
1647 // tmpIndex := 1;
1648 // GetNextQuotedValue(tmpString, tmpIndex, s, '"');
1649 // assertEqualsString('testGetNextQuotedValue', 'ab"c"', s);
1650
1651 tmpResult.Destroy;
1652 END;
1653
1654
1655 PROCEDURE testStrExtractStringsQuoted_ManyParts;
1656 VAR
1657 tmpResult : TStringList;
1658 tmpString : String;
1659 BEGIN
1660 tmpResult := TStringList.Create;
1661 tmpString := 'ab "c" """d" xy z ""';
1662
1663 StrExtractStringsQuoted(tmpResult, tmpString);
1664 assertEqualsInt('testStrExtractStringsQuoted_ManyParts', 6, tmpResult.count);
1665 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'ab', tmpResult[0]);
1666 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'c', tmpResult[1]);
1667 assertEqualsString('testStrExtractStringsQuoted_ManyParts', '"d', tmpResult[2]);
1668 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'xy', tmpResult[3]);
1669 assertEqualsString('testStrExtractStringsQuoted_ManyParts', 'z', tmpResult[4]);
1670 assertEqualsString('testStrExtractStringsQuoted_ManyParts', '', tmpResult[5]);
1671
1672 tmpResult.Destroy;
1673 END;
1674
1675
1676 // ----------------------------------------------------------
1677
1678
1679 PROCEDURE testCaseInsensitivePos_Empty;
1680 VAR
1681 tmpResult : longint;
1682 BEGIN
1683 tmpResult := CaseInsensitivePos('', '');
1684
1685 assertEqualsInt('testCaseInsensitivePos_Empty', Pos('', ''), tmpResult);
1686 END;
1687
1688
1689 PROCEDURE testCaseInsensitivePos_EmptyPart;
1690 VAR
1691 tmpResult : longint;
1692 BEGIN
1693 tmpResult := CaseInsensitivePos('', 'abc');
1694
1695 assertEqualsInt('testCaseInsensitivePos_EmptyPart', Pos('', 'abc'), tmpResult);
1696 END;
1697
1698
1699 PROCEDURE testCaseInsensitivePos_EmptyString;
1700 VAR
1701 tmpResult : longint;
1702 BEGIN
1703 tmpResult := CaseInsensitivePos('abc', '');
1704
1705 assertEqualsInt('testCaseInsensitivePos_EmptyString', Pos('abc', ''), tmpResult);
1706 END;
1707
1708
1709 PROCEDURE testCaseInsensitivePos_PartLarger;
1710 VAR
1711 tmpResult : longint;
1712 BEGIN
1713 tmpResult := CaseInsensitivePos('abc', 'ab');
1714
1715 assertEqualsInt('testCaseInsensitivePos_PartLarger', Pos('abc', 'ab'), tmpResult);
1716 END;
1717
1718
1719 PROCEDURE testCaseInsensitivePos_AtLeft;
1720 VAR
1721 tmpResult : integer;
1722 BEGIN
1723 tmpResult := CaseInsensitivePos('abCd', 'aBcDef');
1724
1725 assertEqualsInt('testCaseInsensitivePos_AtLeft', Pos('abcd', 'abcdef'), tmpResult);
1726 END;
1727
1728
1729 PROCEDURE testCaseInsensitivePos_Middle;
1730 VAR
1731 tmpResult : integer;
1732 BEGIN
1733 tmpResult := CaseInsensitivePos('abCd', '12aBcDef');
1734
1735 assertEqualsInt('testCaseInsensitivePos_Middle', Pos('abcd', '12abcdef'), tmpResult);
1736 END;
1737
1738
1739 PROCEDURE testCaseInsensitivePos_AtRight;
1740 VAR
1741 tmpResult : integer;
1742 BEGIN
1743 tmpResult := CaseInsensitivePos('abCd', 'efaBcD');
1744
1745 assertEqualsInt('testCaseInsensitivePos_AtRight', Pos('abcd', 'efabcd'), tmpResult);
1746 END;
1747
1748
1749 PROCEDURE testCaseInsensitivePos;
1750 VAR
1751 tmpPart : String;
1752 tmpString : String;
1753 tmpResult,i : integer;
1754 BEGIN
1755 tmpPart := '';
1756 tmpString := '';
1757
1758 for i:=1 to 255 do
1759 begin
1760 tmpPart := tmpPart + char(i);
1761 tmpString := tmpString + char(i);
1762 end;
1763
1764 tmpResult := CaseInsensitivePos(tmpPart, UpperCase(tmpString));
1765 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1766
1767 tmpResult := CaseInsensitivePos(UpperCase(tmpPart), tmpString);
1768 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1769
1770 tmpResult := CaseInsensitivePos(tmpPart, LowerCase(tmpString));
1771 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1772
1773 tmpResult := CaseInsensitivePos(LowerCase(tmpPart), tmpString);
1774 assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
1775END;
1776
1777
1778 // --------------------
1779 // ---- AnsiString ----
1780 // --------------------
1781
1782
1783 PROCEDURE testAnsiTrimLeftChars_Empty;
1784 VAR
1785 tmpResult : AnsiString;
1786 tmpValue : AnsiString;
1787 BEGIN
1788 tmpValue := '';
1789 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
1790
1791 assertEqualsAnsiString('testAnsiTrimLeftChars_Empty', '', tmpResult);
1792 END;
1793
1794
1795 PROCEDURE testAnsiTrimLeftChars_RemoveAll;
1796 VAR
1797 tmpResult : AnsiString;
1798 tmpValue : AnsiString;
1799 BEGIN
1800 tmpValue := 'bxxxbx';
1801 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
1802
1803 assertEqualsAnsiString('testAnsiTrimLeftChars_RemoveAll', '', tmpResult);
1804 END;
1805
1806
1807 PROCEDURE testAnsiTrimLeftChars_OneLeft;
1808 VAR
1809 tmpResult : AnsiString;
1810 tmpValue : AnsiString;
1811 BEGIN
1812 tmpValue := 'bxy';
1813 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
1814
1815 assertEqualsAnsiString('testAnsiTrimLeftChars_OneLeft', 'y', tmpResult);
1816 END;
1817
1818
1819 PROCEDURE testAnsiTrimLeftChars_LeftOnly;
1820 VAR
1821 tmpResult : AnsiString;
1822 tmpValue : AnsiString;
1823 BEGIN
1824 tmpValue := 'bxbxxay';
1825 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
1826
1827 assertEqualsAnsiString('testAnsiTrimLeftChars_LeftOnly', 'ay', tmpResult);
1828 END;
1829
1830
1831 PROCEDURE testAnsiTrimLeftChars_CharsInside;
1832 VAR
1833 tmpResult : AnsiString;
1834 tmpValue : AnsiString;
1835 BEGIN
1836 tmpValue := 'bxabxvvx';
1837 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
1838
1839 assertEqualsAnsiString('testAnsiTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
1840 END;
1841
1842
1843 PROCEDURE testAnsiTrimLeftChars_Nothing;
1844 VAR
1845 tmpResult : AnsiString;
1846 tmpValue : AnsiString;
1847 BEGIN
1848 tmpValue := 'acdef';
1849 tmpResult := AnsiStrTrimLeftChars('acdef', ['b', 'x']);
1850
1851 assertEqualsAnsiString('testAnsiTrimLeftChars_Nothing', 'acdef', tmpResult);
1852 END;
1853
1854
1855 PROCEDURE testAnsiTrimLeftChars_ReallyLong;
1856 VAR
1857 tmpResult : AnsiString;
1858 tmpValue : AnsiString;
1859 BEGIN
1860 tmpValue := '0123456789';
1861 tmpValue := tmpValue + tmpValue;
1862 tmpValue := tmpValue + tmpValue;
1863 tmpValue := tmpValue + tmpValue;
1864 tmpValue := tmpValue + tmpValue;
1865 tmpValue := tmpValue + tmpValue;
1866 assertEqualsInt('testAnsiTrimLeftChars_ReallyLong', 320, Length(tmpValue));
1867
1868 tmpResult := AnsiStrTrimLeftChars(tmpValue, ['0', '1']);
1869
1870 assertEqualsInt('testAnsiTrimLeftChars_ReallyLong', 318, Length(tmpResult));
1871 END;
1872
1873
1874 // -------------------------------------------------------------------
1875
1876
1877 PROCEDURE testAnsiTrimRightChars_Empty;
1878 VAR
1879 tmpResult : AnsiString;
1880 tmpValue : AnsiString;
1881 BEGIN
1882 tmpValue := '';
1883 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
1884
1885 assertEqualsAnsiString('testAnsiTrimRightChars_Empty', '', tmpResult);
1886 END;
1887
1888
1889 PROCEDURE testAnsiTrimRightChars_RemoveAll;
1890 VAR
1891 tmpResult : AnsiString;
1892 tmpValue : AnsiString;
1893 BEGIN
1894 tmpValue := 'bxxxbx';
1895 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
1896
1897 assertEqualsAnsiString('testAnsiTrimRightChars_RemoveAll', '', tmpResult);
1898 END;
1899
1900
1901 PROCEDURE testAnsiTrimRightChars_OneLeft;
1902 VAR
1903 tmpResult : AnsiString;
1904 tmpValue : AnsiString;
1905 BEGIN
1906 tmpValue := 'ybx';
1907 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
1908
1909 assertEqualsAnsiString('testAnsiTrimRightChars_OneLeft', 'y', tmpResult);
1910 END;
1911
1912
1913 PROCEDURE testAnsiTrimRightChars_RightOnly;
1914 VAR
1915 tmpResult : AnsiString;
1916 tmpValue : AnsiString;
1917 BEGIN
1918 tmpValue := 'aybxbxx';
1919 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
1920
1921 assertEqualsAnsiString('testAnsiTrimRightChars_RightOnly', 'ay', tmpResult);
1922 END;
1923
1924
1925 PROCEDURE testAnsiTrimRightChars_CharsInside;
1926 VAR
1927 tmpResult : AnsiString;
1928 tmpValue : AnsiString;
1929 BEGIN
1930 tmpValue := 'abxvvxb';
1931 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
1932
1933 assertEqualsAnsiString('testAnsiTrimRightChars_CharsInside', 'abxvv', tmpResult);
1934 END;
1935
1936
1937 PROCEDURE testAnsiTrimRightChars_Nothing;
1938 VAR
1939 tmpResult : AnsiString;
1940 tmpValue : AnsiString;
1941 BEGIN
1942 tmpValue := 'acdef';
1943 tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
1944
1945 assertEqualsAnsiString('testAnsiTrimRightChars_Nothing', 'acdef', tmpResult);
1946 END;
1947
1948
1949 PROCEDURE testAnsiTrimRightChars_ReallyLong;
1950 VAR
1951 tmpResult : AnsiString;
1952 tmpValue : AnsiString;
1953 BEGIN
1954 tmpValue := '0123456789';
1955 tmpValue := tmpValue + tmpValue;
1956 tmpValue := tmpValue + tmpValue;
1957 tmpValue := tmpValue + tmpValue;
1958 tmpValue := tmpValue + tmpValue;
1959 tmpValue := tmpValue + tmpValue;
1960 assertEqualsInt('testAnsiTrimRightChars_ReallyLong', 320, Length(tmpValue));
1961
1962 tmpResult := AnsiStrTrimRightChars(tmpValue, ['8', '9']);
1963
1964 assertEqualsInt('testAnsiTrimRightChars_ReallyLong', 318, Length(tmpResult));
1965 END;
1966
1967
1968 // -------------------------------------------------------------------
1969
1970 PROCEDURE testAnsiTrimChars_Empty;
1971 VAR
1972 tmpResult : AnsiString;
1973 tmpValue : AnsiString;
1974 BEGIN
1975 tmpValue := '';
1976 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
1977
1978 assertEqualsAnsiString('testAnsiTrimChars_Empty', '', tmpResult);
1979 END;
1980
1981
1982 PROCEDURE testAnsiTrimChars_RemoveAll;
1983 VAR
1984 tmpResult : AnsiString;
1985 tmpValue : AnsiString;
1986 BEGIN
1987 tmpValue := 'bxxxbx';
1988 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
1989
1990 assertEqualsAnsiString('testAnsiTrimChars_RemoveAll', '', tmpResult);
1991 END;
1992
1993
1994 PROCEDURE testAnsiTrimChars_OneLeftFromLeft;
1995 VAR
1996 tmpResult : AnsiString;
1997 tmpValue : AnsiString;
1998 BEGIN
1999 tmpValue := 'bxa';
2000 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2001
2002 assertEqualsAnsiString('testAnsiTrimChars_OneLeftFromLeft', 'a', tmpResult);
2003 END;
2004
2005
2006 PROCEDURE testAnsiTrimChars_OneLeftFromRight;
2007 VAR
2008 tmpResult : AnsiString;
2009 tmpValue : AnsiString;
2010 BEGIN
2011 tmpValue := 'abx';
2012 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2013
2014 assertEqualsAnsiString('testAnsiTrimChars_OneLeftFromRight', 'a', tmpResult);
2015 END;
2016
2017
2018 PROCEDURE testAnsiTrimChars_LeftOnly;
2019 VAR
2020 tmpResult : AnsiString;
2021 tmpValue : AnsiString;
2022 BEGIN
2023 tmpValue := 'bxbxxay';
2024 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2025
2026 assertEqualsAnsiString('testAnsiTrimChars_LeftOnly', 'ay', tmpResult);
2027 END;
2028
2029
2030 PROCEDURE testAnsiTrimChars_RightOnly;
2031 VAR
2032 tmpResult : AnsiString;
2033 tmpValue : AnsiString;
2034 BEGIN
2035 tmpValue := 'aybxbxx';
2036 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2037
2038 assertEqualsAnsiString('testAnsiTrimChars_LeftOnly', 'ay', tmpResult);
2039 END;
2040
2041
2042 PROCEDURE testAnsiTrimChars_CharsInside;
2043 VAR
2044 tmpResult : AnsiString;
2045 tmpValue : AnsiString;
2046 BEGIN
2047 tmpValue := 'bxabxvvx';
2048 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2049
2050 assertEqualsAnsiString('testAnsiTrimChars_CharsInside', 'abxvv', tmpResult);
2051 END;
2052
2053
2054 PROCEDURE testAnsiTrimChars_Nothing;
2055 VAR
2056 tmpResult : AnsiString;
2057 tmpValue : AnsiString;
2058 BEGIN
2059 tmpValue := 'acdef';
2060 tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
2061
2062 assertEqualsAnsiString('testAnsiTrimChars_Nothing', 'acdef', tmpResult);
2063 END;
2064
2065
2066 PROCEDURE testAnsiTrimChars_ReallyLong;
2067 VAR
2068 tmpResult : AnsiString;
2069 tmpValue : AnsiString;
2070 BEGIN
2071 tmpValue := '0123456789';
2072 tmpValue := tmpValue + tmpValue;
2073 tmpValue := tmpValue + tmpValue;
2074 tmpValue := tmpValue + tmpValue;
2075 tmpValue := tmpValue + tmpValue;
2076 tmpValue := tmpValue + tmpValue;
2077 assertEqualsInt('testAnsiTrimChars_ReallyLong', 320, Length(tmpValue));
2078
2079 tmpResult := AnsiStrTrimChars(tmpValue, ['8', '9', '0', '1']);
2080
2081 assertEqualsInt('testAnsiTrimChars_ReallyLong', 316, Length(tmpResult));
2082 END;
2083
2084
2085 // -------------------------------------------------------------------
2086
2087
2088 PROCEDURE testAnsiTrim;
2089 VAR
2090 tmpResult : String;
2091 tmpValue : AnsiString;
2092 BEGIN
2093 tmpValue := ' a bc ';
2094 tmpResult := AnsiStrTrim(tmpValue);
2095
2096 assertEqualsAnsiString('testAnsiTrim', 'a bc', tmpResult);
2097 END;
2098
2099
2100 PROCEDURE testAnsiTrim_ReallyLong;
2101 VAR
2102 tmpResult : AnsiString;
2103 tmpValue : AnsiString;
2104 BEGIN
2105 tmpValue := '0123456789';
2106 tmpValue := tmpValue + tmpValue;
2107 tmpValue := tmpValue + tmpValue;
2108 tmpValue := tmpValue + tmpValue;
2109 tmpValue := tmpValue + tmpValue;
2110 tmpValue := tmpValue + tmpValue;
2111 tmpValue := ' ' + tmpValue + ' ';
2112 assertEqualsInt('testAnsiTrim_ReallyLong', 326, Length(tmpValue));
2113
2114 tmpResult := AnsiStrTrim(tmpValue);
2115
2116 assertEqualsInt('testAnsiTrim_ReallyLong', 320, Length(tmpResult));
2117 END;
2118
2119
2120 // -------------------------------------------------------------------
2121
2122
2123 FUNCTION getStringUtilsUnitTests : TList;
2124 BEGIN
2125 result := TList.Create;
2126
2127 result.add(@testTSerializableStringList_Construction);
2128 result.add(@testTSerializableStringList_Add);
2129 result.add(@testTSerializableStringList_Get_Empty);
2130 result.add(@testTSerializableStringList_Get);
2131 result.add(@testTSerializableStringList_getSerializedString_Empty);
2132 result.add(@testTSerializableStringList_getSerializedString);
2133 result.add(@testTSerializableStringList_getSerializedString);
2134 result.add(@testTSerializableStringList_getSerializedString_WithBlanks);
2135 result.add(@testTSerializableStringList_getSerializedString_Escaping);
2136 result.add(@testTSerializableStringList_readValuesFromSerializedString);
2137 result.add(@testTSerializableStringList_readValuesFromSerializedString_quoted);
2138 result.add(@testTSerializableStringList_readValuesFromSerializedString_empty);
2139 result.add(@testTSerializableStringList_readValuesFromSerializedString_firstempty);
2140 result.add(@testTSerializableStringList_readValuesFromSerializedString_2);
2141
2142 result.add(@testEscapeAllCharsBy);
2143 result.add(@testEscapeAllCharsBy_Empty);
2144 result.add(@testEscapeAllCharsBy_EmptyChars);
2145 result.add(@testEscapeAllCharsBy_EscapeEscape);
2146
2147 result.add(@testStrExtractStrings_EmptyReceiver);
2148 result.add(@testStrExtractStrings_OnlyOnePart);
2149 result.add(@testStrExtractStrings_ManyParts);
2150 result.add(@testStrExtractStrings_StartWithDelimiter);
2151 result.add(@testStrExtractStrings_EndWithDelimiter);
2152 result.add(@testStrExtractStrings_EmptyPartInside);
2153 result.add(@testStrExtractStrings_NoDelimiter);
2154 result.add(@testStrExtractStrings_EscapedDelimiter);
2155 result.add(@testStrExtractStrings_EscapedEscapeChar);
2156 result.add(@testStrExtractStrings_DelimiterSameAsEscapeChar);
2157
2158 result.add(@testStrExtractStringsIgnoreEmpty_EmptyReceiver);
2159 result.add(@testStrExtractStringsIgnoreEmpty_OnlyOnePart);
2160 result.add(@testStrExtractStringsIgnoreEmpty_ManyParts);
2161 result.add(@testStrExtractStringsIgnoreEmpty_StartWithDelimiter);
2162 result.add(@testStrExtractStringsIgnoreEmpty_EndWithDelimiter);
2163 result.add(@testStrExtractStringsIgnoreEmpty_EmptyPartInside);
2164 result.add(@testStrExtractStringsIgnoreEmpty_NoDelimiter);
2165 result.add(@testStrExtractStringsIgnoreEmpty_EscapedDelimiter);
2166 result.add(@testStrExtractStringsIgnoreEmpty_EscapedEscapeChar);
2167
2168 result.add(@testTrimLeftChars_Empty);
2169 result.add(@testTrimLeftChars_RemoveAll);
2170 result.add(@testTrimLeftChars_OneLeft);
2171 result.add(@testTrimLeftChars_LeftOnly);
2172 result.add(@testTrimLeftChars_CharsInside);
2173 result.add(@testTrimLeftChars_Nothing);
2174
2175 result.add(@testTrimRightChars_Empty);
2176 result.add(@testTrimRightChars_RemoveAll);
2177 result.add(@testTrimRightChars_OneLeft);
2178 result.add(@testTrimRightChars_RightOnly);
2179 result.add(@testTrimRightChars_CharsInside);
2180 result.add(@testTrimRightChars_Nothing);
2181
2182 result.add(@testTrimChars_Empty);
2183 result.add(@testTrimChars_RemoveAll);
2184 result.add(@testTrimChars_OneLeftFromLeft);
2185 result.add(@testTrimChars_OneLeftFromRight);
2186 result.add(@testTrimChars_LeftOnly);
2187 result.add(@testTrimChars_RightOnly);
2188 result.add(@testTrimChars_CharsInside);
2189 result.add(@testTrimChars_Nothing);
2190
2191 result.add(@testTrim);
2192
2193 result.add(@testStrLeft_Empty);
2194 result.add(@testStrLeft_Nothing);
2195 result.add(@testStrLeft_WholeString);
2196 result.add(@testStrLeft_ToManyRequested);
2197 result.add(@testStrLeft_Part);
2198
2199 result.add(@testStrLeftWithout_Empty);
2200 result.add(@testStrLeftWithout_ToBig);
2201 result.add(@testStrLeftWithout_Negative);
2202 result.add(@testStrLeftWithout_All);
2203 result.add(@testStrLeftWithout);
2204
2205 result.add(@testStrLeftUntil_Empty);
2206 result.add(@testStrLeftUntil_Empty_EmptyDelimiterSet);
2207 result.add(@testStrLeftUntil_EmptyDelimiterSet);
2208 result.add(@testStrLeftUntil_FirstIsDelimiter);
2209 result.add(@testStrLeftUntil_LastIsDelimiter);
2210 result.add(@testStrLeftUntil_UnusedDelimiter);
2211 result.add(@testStrLeftUntil);
2212
2213 result.add(@testStrStartsWith_BothEmpty);
2214 result.add(@testStrStartsWith_StringEmpty);
2215 result.add(@testStrStartsWith_MatchEmpty);
2216 result.add(@testStrStartsWith_StringToShort);
2217 result.add(@testStrStartsWith_StringEqualLength);
2218 result.add(@testStrStartsWith_StringEqualLengthMatch);
2219 result.add(@testStrStartsWith_StringMatch);
2220 result.add(@testStrStartsWith_StringMatchCaseSensitive);
2221
2222 result.add(@testStrStartsWithIgnoringCase_BothEmpty);
2223 result.add(@testStrStartsWithIgnoringCase_StringEmpty);
2224 result.add(@testStrStartsWithIgnoringCase_MatchEmpty);
2225 result.add(@testStrStartsWithIgnoringCase_StringToShort);
2226 result.add(@testStrStartsWithIgnoringCase_StringEqualLength);
2227 result.add(@testStrStartsWithIgnoringCase_StringEqualLengthMatch);
2228 result.add(@testStrStartsWithIgnoringCase_StringMatch);
2229 result.add(@testStrStartsWithIgnoringCase_StringMatchCaseInSensitive);
2230
2231 result.add(@testStrEndsWith_BothEmpty);
2232 result.add(@testStrEndsWith_StringEmpty);
2233 result.add(@testStrEndsWith_MatchEmpty);
2234 result.add(@testStrEndsWith_StringToShort);
2235 result.add(@testStrEndsWith_StringEqualLength);
2236 result.add(@testStrEndsWith_StringEqualLengthMatch);
2237 result.add(@testStrEndsWith_StringMatch);
2238 result.add(@testStrEndsWith_StringMatchCaseSensitive);
2239
2240 result.add(@testStrEndsWithIgnoringCase_BothEmpty);
2241 result.add(@testStrEndsWithIgnoringCase_StringEmpty);
2242 result.add(@testStrEndsWithIgnoringCase_MatchEmpty);
2243 result.add(@testStrEndsWithIgnoringCase_StringToShort);
2244 result.add(@testStrEndsWithIgnoringCase_StringEqualLength);
2245 result.add(@testStrEndsWithIgnoringCase_StringEqualLengthMatch);
2246 result.add(@testStrEndsWithIgnoringCase_StringMatch);
2247 result.add(@testStrEndsWithIgnoringCase_StringMatchCaseInSensitive);
2248
2249 result.add(@testStrEqualIgnoringCase_BothEmpty);
2250 result.add(@testStrEqualIgnoringCase_FirstEmpty);
2251 result.add(@testStrEqualIgnoringCase_SecondEmpty);
2252 result.add(@testStrEqualIgnoringCase_DifferentLength);
2253 result.add(@testStrEqualIgnoringCase_DifferentCase);
2254 result.add(@testStrEqualIgnoringCase);
2255
2256 result.add(@testLongWordToStr_Zero);
2257 result.add(@testLongWordToStr_Four);
2258 result.add(@testLongWordToStr_Max);
2259
2260 result.add(@testBoolToStr_true);
2261 result.add(@testBoolToStr_false);
2262
2263 result.add(@testStrInDoubleQuotes_Empty);
2264 result.add(@testStrInDoubleQuotes);
2265
2266 result.add(@testStrExtractStringsQuoted_Empty);
2267 result.add(@testStrExtractStringsQuoted_OnlyWhitespace);
2268 result.add(@testStrExtractStringsQuoted_OnlyText);
2269 result.add(@testStrExtractStringsQuoted_OnlyText2Parts);
2270 result.add(@testStrExtractStringsQuoted_TextAndWhitespace2Parts);
2271 result.add(@testStrExtractStringsQuoted_QuotedText1Part);
2272 result.add(@testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotes);
2273 result.add(@testStrExtractStringsQuoted_QuotedText1PartNoClosingQuotesWhitewspace);
2274 result.add(@testStrExtractStringsQuoted_QuotedText1PartQuoteInside);
2275 result.add(@testStrExtractStringsQuoted_QuotedText1Part2QuotesInside);
2276 result.add(@testStrExtractStringsQuoted_QuotedText1Part2Quotes);
2277 result.add(@testStrExtractStringsQuoted_Only1Quote);
2278 result.add(@testStrExtractStringsQuoted_Only1QuoteAndWhitespace);
2279 result.add(@testStrExtractStringsQuoted_QuoteStartsNewPart);
2280 result.add(@testStrExtractStringsQuoted_ManyParts);
2281
2282 result.add(@testCaseInsensitivePos_Empty);
2283 result.add(@testCaseInsensitivePos_EmptyPart);
2284 result.add(@testCaseInsensitivePos_EmptyString);
2285 result.add(@testCaseInsensitivePos_PartLarger);
2286 result.add(@testCaseInsensitivePos_AtLeft);
2287 result.add(@testCaseInsensitivePos_Middle);
2288 result.add(@testCaseInsensitivePos_AtRight);
2289 result.add(@testCaseInsensitivePos);
2290
2291 // --------------------
2292 // ---- AnsiString ----
2293 // --------------------
2294
2295
2296 result.add(@testAnsiTrimLeftChars_Empty);
2297 result.add(@testAnsiTrimLeftChars_RemoveAll);
2298 result.add(@testAnsiTrimLeftChars_OneLeft);
2299 result.add(@testAnsiTrimLeftChars_LeftOnly);
2300 result.add(@testAnsiTrimLeftChars_CharsInside);
2301 result.add(@testAnsiTrimLeftChars_Nothing);
2302 result.add(@testAnsiTrimLeftChars_ReallyLong);
2303
2304 result.add(@testAnsiTrimRightChars_Empty);
2305 result.add(@testAnsiTrimRightChars_RemoveAll);
2306 result.add(@testAnsiTrimRightChars_OneLeft);
2307 result.add(@testAnsiTrimRightChars_RightOnly);
2308 result.add(@testAnsiTrimRightChars_CharsInside);
2309 result.add(@testAnsiTrimRightChars_Nothing);
2310 result.add(@testAnsiTrimRightChars_ReallyLong);
2311
2312 result.add(@testAnsiTrimChars_Empty);
2313 result.add(@testAnsiTrimChars_RemoveAll);
2314 result.add(@testAnsiTrimChars_OneLeftFromLeft);
2315 result.add(@testAnsiTrimChars_OneLeftFromRight);
2316 result.add(@testAnsiTrimChars_LeftOnly);
2317 result.add(@testAnsiTrimChars_RightOnly);
2318 result.add(@testAnsiTrimChars_CharsInside);
2319 result.add(@testAnsiTrimChars_Nothing);
2320 result.add(@testAnsiTrimChars_ReallyLong);
2321
2322 result.add(@testAnsiTrim);
2323 result.add(@testAnsiTrim_ReallyLong);
2324
2325
2326 END;
2327
2328END.
Note: See TracBrowser for help on using the repository browser.