source: trunk/unittests/StringUtilsUnitTests.pas@ 265

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

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