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

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

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