mirror of
https://gitlab.com/freepascal.org/fpc/pas2js.git
synced 2025-04-06 00:07:44 +02:00
1159 lines
36 KiB
ObjectPascal
1159 lines
36 KiB
ObjectPascal
unit tcstringhelp;
|
|
|
|
{$mode objfpc}{$H+}
|
|
//{$modeswitch advancedrecords}
|
|
//{$modeswitch typehelpers}
|
|
|
|
interface
|
|
|
|
uses
|
|
SysUtils, fpcunit, testregistry;
|
|
|
|
Const
|
|
TBI = 'To be implemented';
|
|
|
|
Type
|
|
TTestStringHelper = Class(TTestCase)
|
|
Public
|
|
Function TestArray(Msg : string; Aexpected : Array of string; AActual : TStringArray) : boolean;
|
|
Published
|
|
Procedure TestCompare;
|
|
Procedure TestCompareOrdinal;
|
|
Procedure TestCompareText;
|
|
Procedure TestCopy;
|
|
Procedure TestCreate;
|
|
Procedure TestEndsText;
|
|
Procedure TestEquals;
|
|
Procedure TestFormat;
|
|
Procedure TestIsNullOrEmpty;
|
|
Procedure TestIsNullOrWhiteSpace;
|
|
Procedure TestJoin;
|
|
Procedure TestLowerCase;
|
|
Procedure TestParse;
|
|
Procedure TestToBoolean;
|
|
Procedure TestToDouble;
|
|
Procedure TestToExtended;
|
|
Procedure TestToInt64;
|
|
Procedure TestToInteger;
|
|
Procedure TestUppercase;
|
|
Procedure TestCompareTo;
|
|
Procedure TestContains;
|
|
Procedure TestCountChar;
|
|
Procedure TestDeQuotedString;
|
|
Procedure TestEndsWith;
|
|
Procedure TestGetHashCode;
|
|
Procedure TestIndexOf;
|
|
Procedure TestIndexOfAny;
|
|
Procedure TestIndexOfAnyString;
|
|
Procedure TestIndexOfUnquoted;
|
|
Procedure TestIndexOfAnyUnquoted;
|
|
Procedure TestInsert;
|
|
Procedure TestIsDelimiter;
|
|
Procedure TestIsEmpty;
|
|
Procedure TestLastDelimiter;
|
|
Procedure TestLastIndexOf;
|
|
Procedure TestLastIndexOfString;
|
|
Procedure TestLastIndexOfAny;
|
|
Procedure TestPadLeft;
|
|
Procedure TestPadRight;
|
|
Procedure TestQuotedString;
|
|
Procedure TestRemove;
|
|
Procedure TestReplace;
|
|
Procedure TestSplit;
|
|
Procedure TestSplitString;
|
|
Procedure TestStartsWith;
|
|
Procedure TestSubstring;
|
|
Procedure TestToCharArray;
|
|
Procedure TestToLower;
|
|
Procedure TestToLowerInvariant;
|
|
Procedure TestToUpper;
|
|
Procedure TestToUpperInvariant;
|
|
Procedure TestTrim;
|
|
Procedure TestTrimLeft;
|
|
Procedure TestTrimRight;
|
|
Procedure TestTrimEnd;
|
|
Procedure TestTrimStart;
|
|
Procedure TestChars;
|
|
Procedure TestLength;
|
|
end;
|
|
|
|
implementation
|
|
|
|
Procedure TTestStringHelper.TestCompare;
|
|
|
|
Var
|
|
r : Integer;
|
|
|
|
begin
|
|
// Simple cases
|
|
R:=String.Compare('A','B');
|
|
AssertTrue('1. Simple Compare strings (A,B) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.Compare('B','A');
|
|
AssertTrue('2. Simple Compare strings (B,A) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.Compare('A','A');
|
|
AssertTrue('3. Simple Compare strings (A,A) :'+IntToStr(R)+'=0',R=0);
|
|
R:=String.Compare('A','a', true);
|
|
AssertTrue('4. Simple ignore case Compare strings (A,a) : '+IntToStr(R)+'=0',R=0);
|
|
R:=String.Compare('b','a',True);
|
|
AssertTrue('5. Simple ignore case Compare strings (b,a) : '+IntToStr(R)+'>0',R>0);
|
|
R:=String.Compare('A','a',[coIgnoreCase]);
|
|
AssertTrue('6. [coIgnoreCase] Compare strings (A,a) : '+IntToStr(R)+'=0',R=0);
|
|
R:=String.Compare('b','a',[coIgnoreCase]);
|
|
AssertTrue('7. [coIgnoreCase] Compare strings (b,a) : '+IntToStr(R)+'>0',R>0);
|
|
// Check whether index is observed.
|
|
R:=String.Compare('AA',1,'AB',1,1);
|
|
AssertTrue('8. Compare(''AA'',1,''AB'',1,1) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.Compare('AB',1,'AA',1,1);
|
|
AssertTrue('9. Compare(''AB'',1,''AA'',1,1) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.Compare('AA',1,'AA',1,1);
|
|
AssertTrue('10. Compare(''AA'',1,''AA'',1,1) :'+IntToStr(R)+'=0',R=0);
|
|
// Make sure only len chars are used.
|
|
R:=String.Compare('AAC',1,'ABD',1,1);
|
|
AssertTrue('11. Compare(''AAC'',1,''ABD'',1,1) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.Compare('ABC',1,'AAD',1,1);
|
|
AssertTrue('12 Compare(''ABC'',1,''AAD'',1,1) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.Compare('AAC',1,'AAD',1,1);
|
|
AssertTrue('13. Compare(''AAC'',1,''AAD'',1,1) :'+IntToStr(R)+'=0',R=0);
|
|
// Index, case insensitive
|
|
R:=String.Compare('AA',1,'Aa',1,1,true);
|
|
AssertTrue('14. Compare(''AA'',1,''Aa'',1,1,true) : '+IntToStr(R)+'=0',R=0);
|
|
R:=String.Compare('Ab',1,'Aa',1,1,True);
|
|
AssertTrue('15. Compare(''Ab'',1,''Aa'',1,1,True) : '+IntToStr(R)+'>0',R>0);
|
|
R:=String.Compare('A',1,'a',1,1,[coIgnoreCase]);
|
|
AssertTrue('16. Compare(''A'',1,''a'',1,1,[coIgnoreCase]) : '+IntToStr(R)+'=0',R=0);
|
|
// Index, maxlen, case insensitive
|
|
R:=String.Compare('AAC',1,'AaD',1,1,true);
|
|
AssertTrue('17. Compare(''AAC'',1,''AaD'',1,1,true) : '+IntToStr(R)+'=0',R=0);
|
|
R:=String.Compare('AbC',1,'AaD',1,1,True);
|
|
AssertTrue('18. Compare(''AbC'',1,''AaD'',1,1,True) : '+IntToStr(R)+'>0',R>0);
|
|
R:=String.Compare('AAC',1,'AaD',1,1,[coIgnoreCase]);
|
|
AssertTrue('19. Compare(''AAC'',1,''AaD'',1,1,[coIgnoreCase]) : '+IntToStr(R)+'=0',R=0);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestCompareOrdinal;
|
|
|
|
Var
|
|
r : Integer;
|
|
|
|
begin
|
|
// Simple
|
|
R:=String.CompareOrdinal('A','B');
|
|
AssertTrue('1. Simple Compare strings (A,B) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.CompareOrdinal('B','A');
|
|
AssertTrue('2. Simple Compare strings (B,A) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.CompareOrdinal('A','A');
|
|
AssertTrue('3. Simple Compare strings (A,A) :'+IntToStr(R)+'=0',R=0);
|
|
// Index
|
|
R:=String.CompareOrdinal('AA',1,'AB',1,1);
|
|
AssertTrue('4. Simple Compare strings (AA,1,AB,1,1) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.CompareOrdinal('AB',1,'AA',1,1);
|
|
AssertTrue('5. Simple Compare strings (AB,1,AA,1,1) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.CompareOrdinal('AA',1,'AA',1,1);
|
|
AssertTrue('6. Simple Compare strings (AA,1,AA,1,1) :'+IntToStr(R)+'=0',R=0);
|
|
// Index, maxlen
|
|
R:=String.CompareOrdinal('AAC',1,'ABD',1,1);
|
|
AssertTrue('7. Simple Compare strings (AAC,1,ABD,1,1) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.CompareOrdinal('ABC',1,'AAD',1,1);
|
|
AssertTrue('8. Simple Compare strings (ABC,1,AAD,1,1) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.CompareOrdinal('AAD',1,'AAD',1,1);
|
|
AssertTrue('9. Simple Compare strings (AAC,1,AAD,1,1) :'+IntToStr(R)+'=0',R=0);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestCompareText;
|
|
|
|
Var
|
|
r : Integer;
|
|
|
|
begin
|
|
R:=String.CompareText('A','B');
|
|
AssertTrue('1. Simple Compare strings (A,B) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.CompareText('B','A');
|
|
AssertTrue('Simple Compare strings (B,A) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.CompareText('A','A');
|
|
AssertTrue('Simple Compare strings (A,A) :'+IntToStr(R)+'=0',R=0);
|
|
//
|
|
R:=String.CompareText('A','b');
|
|
AssertTrue('Simple Compare strings (A,b) :'+IntToStr(R)+'<0',R<0);
|
|
R:=String.CompareText('B','a');
|
|
AssertTrue('Simple Compare strings (B,a) :'+IntToStr(R)+'>0',R>0);
|
|
R:=String.CompareText('A','a');
|
|
AssertTrue('Simple Compare strings (A,a) :'+IntToStr(R)+'=0',R=0);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestCopy;
|
|
|
|
var
|
|
A,S : String;
|
|
|
|
begin
|
|
A:=TBI;
|
|
S:=String.Copy(A);
|
|
AssertEquals('Copy creates equal copy',A,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestCreate;
|
|
|
|
Var
|
|
A : String;
|
|
|
|
begin
|
|
A:=String.Create('*',5);
|
|
AssertEquals('Create with char and length','*****',A);
|
|
A:=String.Create(['a','b','c','d','e']);
|
|
AssertEquals('Create with array of char','abcde',A);
|
|
A:=String.Create(['a','b','c','d','e'],1,3);
|
|
AssertEquals('Create with array of char and index, len','bcd',A);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestEndsText;
|
|
|
|
begin
|
|
AssertTrue('1. EndsText, correct',String.EndsText('be','to be or not to be'));
|
|
AssertTrue('2. EndsText, correct, case insensitive',String.EndsText('BE','to be or not to be'));
|
|
AssertFalse('3. EndsText, not correct',String.EndsText('de','to be or not to be'));
|
|
AssertFalse('4. EndsText, empty',String.EndsText('','to be or not to be'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestEquals;
|
|
|
|
Var
|
|
A,B : String;
|
|
|
|
begin
|
|
A:='Yes';
|
|
B:='No';
|
|
AssertFalse('1. Equals(A,B)',String.Equals(A,B));
|
|
B:='Yes';
|
|
AssertTrue('2. Equals(A,B)',String.Equals(A,B));
|
|
B:='No';
|
|
AssertFalse('3. A.Equals(B)',A.Equals(B));
|
|
B:='Yes';
|
|
AssertTrue('4. A.Equals(B)',A.Equals(B));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestFormat;
|
|
|
|
|
|
begin
|
|
AssertEquals('1. Format as class function','A1 BC', String.Format('A%d B%s',[1,'C']));
|
|
AssertEquals('2. Format function','A1 BC', 'A%d B%s'.Format([1,'C']));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIsNullOrEmpty;
|
|
|
|
begin
|
|
AssertTrue('1. Empty string returns true',String.IsNullOrEmpty(''));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIsNullOrWhiteSpace;
|
|
|
|
Var
|
|
C : Char;
|
|
begin
|
|
AssertTrue('2. Empty string returns true',String.IsNullOrWhitespace(''));
|
|
For C:=#1 to #32 do
|
|
AssertTrue('Char '+IntToStr(Ord(C))+' string is whitespace',String.IsNullOrWhiteSpace(C));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestJoin;
|
|
|
|
begin
|
|
AssertEquals('1 element','ABC',String.Join(' ',['ABC']));
|
|
AssertEquals('2 elements','ABC DEF',String.Join(' ',['ABC','DEF']));
|
|
AssertEquals('3 elements','ABC DEF GHI',String.Join(' ',['ABC','DEF','GHI']));
|
|
AssertEquals('5 elements, index','ABC DEF GHI',String.Join(' ',['NONO','ABC','DEF','GHI','nono'],1,3));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestLowerCase;
|
|
|
|
begin
|
|
AssertEquals('1. Simple Lowercase','abc',String.Lowercase('ABC'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestParse;
|
|
|
|
Var
|
|
E : Extended;
|
|
begin
|
|
E:=12.3;
|
|
AssertEquals('Boolean','-1',String.Parse(True));
|
|
AssertEquals('Integer','12',String.Parse(Integer(12)));
|
|
AssertEquals('Int64','45',String.Parse(NativeInt(45)));
|
|
AssertEquals('Extended',FloatToStr(E),String.Parse(E));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToBoolean;
|
|
|
|
begin
|
|
AssertTrue('Class function, true',String.ToBoolean('True'));
|
|
AssertTrue('function 1',String.ToBoolean('1'));
|
|
AssertFalse('Class function false',String.ToBoolean('False'));
|
|
AssertFalse('function 0',String.ToBoolean('0'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToDouble;
|
|
|
|
begin
|
|
AssertEquals('Class function, 0',0.0,String.ToDouble('0.0'),0.1);
|
|
AssertEquals('Class function, 1.2',1.2,String.ToDouble('1.2'),0.1);
|
|
AssertEquals('function, 0',0.0,'0.0'.ToDouble,0.1);
|
|
AssertEquals('function, 1.2',1.2,'1.2'.ToDouble,0.1);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToExtended;
|
|
|
|
begin
|
|
AssertEquals('Class function, 0',0.0,String.ToExtended('0.0'),0.1);
|
|
AssertEquals('Class function, 1.2',1.2,String.ToExtended('1.2'),0.1);
|
|
AssertEquals('function, 0',0.0,'0.0'.ToExtended,0.1);
|
|
AssertEquals('function, 1.2',1.2,'1.2'.ToExtended,0.1);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToInt64;
|
|
|
|
begin
|
|
AssertEquals('Class function, 0',0,String.ToNativeInt('0'));
|
|
AssertEquals('Class function, 12',12,String.ToNativeInt('12'));
|
|
AssertEquals('Class function, 1234567890123',1234567890123,String.ToNativeInt('1234567890123'));
|
|
// 2 characters because it does not work on length 1, compiler assumes Char as in Delphi
|
|
AssertEquals('Class function, 0',0,'00'.ToNativeInt);
|
|
AssertEquals('Class function, 12',12,'12'.ToNativeInt);
|
|
AssertEquals('Class function, 1234567890123',1234567890123,'1234567890123'.ToNativeInt);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToInteger;
|
|
|
|
begin
|
|
AssertEquals('Class function, 0',0,String.ToInteger('0'));
|
|
AssertEquals('Class function, 12',12,String.ToInteger('12'));
|
|
AssertEquals('Class function, 123456789',123456789,String.ToInteger('123456789'));
|
|
// 2 characters because it does not work on length 1, compiler assumes Char as in Delphi
|
|
AssertEquals('Class function, 0',0,'00'.ToInteger);
|
|
AssertEquals('Class function, 12',12,'12'.ToInteger);
|
|
AssertEquals('Class function, 123456789',123456789,'123456789'.ToInteger);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestUppercase;
|
|
|
|
begin
|
|
AssertEquals('1. Simple Lowercase','ABC',String.UpperCase('abc'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestCompareTo;
|
|
|
|
begin
|
|
// 2 characters because it does not work on length 1, compiler assumes Char as in Delphi
|
|
AssertTrue('1. A<B','AA'.CompareTo('AB')<0);
|
|
AssertTrue('1. A=A','AA'.CompareTo('AA')=0);
|
|
AssertTrue('1. B>A','AB'.CompareTo('AA')>0);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestContains;
|
|
|
|
begin
|
|
AssertTrue('ABC contains AB','ABC'.Contains('AB'));
|
|
AssertTrue('ABC contains BC','ABC'.Contains('BC'));
|
|
AssertTrue('ABC contains B','ABC'.Contains('B'));
|
|
AssertFalse('ABC does not contain empty','ABC'.Contains(''));
|
|
AssertFalse('ABC does not contain DEF','ABC'.Contains('DEF'));
|
|
AssertFalse('ABC does not contain a','ABC'.Contains('a'));
|
|
end;
|
|
|
|
(*
|
|
// No PChar support
|
|
|
|
Procedure TTestStringHelper.TestCopyTo;
|
|
|
|
Type
|
|
TCharArray = Array Of Char;
|
|
|
|
Const
|
|
Res1 : Array[0..4] of Char = ('T','o',' ','b','e');
|
|
|
|
Var
|
|
S : String;
|
|
A : TCharArray;
|
|
I : Integer;
|
|
|
|
begin
|
|
A:=Default(TCharArray);
|
|
S:=TBI;
|
|
SetLength(A,5);
|
|
S.CopyTo(0,A,0,5);
|
|
For I:=0 to 4 do
|
|
AssertEquals('Zero indexes, Char '+IntToStr(i),Res1[I],A[I]);
|
|
S:='AB'+S;
|
|
S.CopyTo(2,A,0,5);
|
|
For I:=0 to 4 do
|
|
AssertEquals('Source index, zero dest index, Char '+IntToStr(i),Res1[I],A[I]);
|
|
SetLength(A,8);
|
|
S.CopyTo(2,A,3,5);
|
|
For I:=0 to 4 do
|
|
AssertEquals('Source index, dest index, Char '+IntToStr(i),Res1[I],A[I+3]);
|
|
end;
|
|
*)
|
|
|
|
Procedure TTestStringHelper.TestCountChar;
|
|
|
|
begin
|
|
AssertEquals('Empty string',0,''.CountChar(' '));
|
|
AssertEquals('Start and end ',2,' ** '.CountChar(' '));
|
|
AssertEquals('Middle',2,'* *'.CountChar(' '));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestDeQuotedString;
|
|
|
|
Const
|
|
C = TBI;
|
|
C2 = 'To be ''implemented';
|
|
C3 = 'To be "implemented';
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=''''+C+'''';
|
|
AssertEquals('Simple case of '+S,C,S.DequotedString);
|
|
S:=''''+StringReplace(C2,'''','''''',[rfReplaceAll])+'''';
|
|
AssertEquals('Quoted case of '+S,C2,S.DequotedString);
|
|
S:='"'+C+'"';
|
|
AssertEquals('Simple case of '+S,C,S.DequotedString('"'));
|
|
S:='"'+StringReplace(C3,'"','""',[rfReplaceAll])+'"';
|
|
AssertEquals('Quoted case of '+S,C3,S.DequotedString('"'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestEndsWith;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertTrue('length 0', S.EndsWith(''));
|
|
AssertTrue('length 1', S.EndsWith('d'));
|
|
AssertTrue('length 2', S.EndsWith('ed'));
|
|
AssertTrue('equal length (same)', S.EndsWith(S));
|
|
AssertFalse('length+2', S.EndsWith(S+'ed'));
|
|
AssertFalse('Random string', S.EndsWith('erd'));
|
|
AssertTrue('match case ', S.EndsWith('ed',False));
|
|
AssertFalse('match case, no match ', S.EndsWith('eD',False));
|
|
AssertTrue('no match case, match ', S.EndsWith('ED',True));
|
|
AssertFalse('no match case, no match ', S.EndsWith('DED',True));
|
|
end;
|
|
Procedure TTestStringHelper.TestGetHashCode;
|
|
{
|
|
Function GetHashCode: Integer;
|
|
}
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertTrue('Nonzero hashcode',S.GetHashCode<>0);
|
|
// A more meaningful test would be nice...
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIndexOf;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI+' To perfection';
|
|
// Char based.
|
|
AssertEquals('Char, Nonexisting returns -1',-1,S.IndexOf('a'));
|
|
AssertEquals('Char, Existing, zero based',0,S.IndexOf('T'));
|
|
AssertEquals('Char, Case sensitive',-1,S.IndexOf('I'));
|
|
AssertEquals('Char, using start index',10,S.IndexOf('e',5));
|
|
AssertEquals('Char, using start index and count, not found',-1,S.IndexOf('e',5,5));
|
|
AssertEquals('Char, using start index and count,found',10,S.IndexOf('e',5,6));
|
|
// String based.
|
|
AssertEquals('String, Nonexisting returns -1',-1,S.IndexOf('a'));
|
|
AssertEquals('String, zero based',0,S.IndexOf('T'));
|
|
AssertEquals('String, case sensitive',-1,S.IndexOf('I'));
|
|
AssertEquals('String, using start index',18,S.IndexOf('To',2));
|
|
AssertEquals('String, using start index and count ',-1,S.IndexOf('To be',2,4));
|
|
AssertEquals('String, using start index and count (partial overlap)',-1,S.IndexOf('To be',16,4));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIndexOfAny;
|
|
|
|
Var
|
|
S : String;
|
|
ES : Array of Char;
|
|
begin
|
|
S:=TBI;
|
|
es:=[];
|
|
// Just a set
|
|
SetLength(ES,0);
|
|
AssertEquals('Empty set',-1,S.IndexOfAny(ES));
|
|
AssertEquals('Single char in set, no match',-1,S.IndexOfAny(['a']));
|
|
AssertEquals('Single char in set, no match (wrong case)',-1,S.IndexOfAny(['O']));
|
|
AssertEquals('2 chars in set, no match',-1,S.IndexOfAny(['a','z']));
|
|
AssertEquals('Single char in set, match',4,S.IndexOfAny(['e']));
|
|
AssertEquals('2 chars in set, 2nd matches',3,S.IndexOfAny(['a','b']));
|
|
// Start index
|
|
AssertEquals('StartIndex, Empty set',-1,S.IndexOfAny(ES,2));
|
|
AssertEquals('StartIndex, Single char in set, no match',-1,S.IndexOfAny(['a'],2));
|
|
AssertEquals('StartIndex, Single char in set, no match (wrong case)',-1,S.IndexOfAny(['O'],1));
|
|
AssertEquals('StartIndex, Single char in set, no match (index too big)',-1,S.IndexOfAny(['o'],2));
|
|
AssertEquals('StartIndex, 2 chars in set, no match',-1,S.IndexOfAny(['a','z'],4));
|
|
AssertEquals('StartIndex, Single char in set, match',4,S.IndexOfAny(['e'],3));
|
|
AssertEquals('StartIndex, 2 chars in set, 2nd matches',3,S.IndexOfAny(['a','b'],2));
|
|
// Start index, count
|
|
AssertEquals('StartIndex, count, Empty set',-1,S.IndexOfAny(ES,2,3));
|
|
AssertEquals('StartIndex, count, Single char in set, no match',-1,S.IndexOfAny(['a'],2));
|
|
AssertEquals('StartIndex, count, Single char in set, no match (wrong case)',-1,S.IndexOfAny(['O'],1));
|
|
AssertEquals('StartIndex, count, Single char in set, no match (index too big)',-1,S.IndexOfAny(['o'],2,4));
|
|
AssertEquals('StartIndex, count, Single char in set, no match (index too big, count too small)',-1,S.IndexOfAny(['o'],5,5));
|
|
AssertEquals('StartIndex, count, 2 chars in set, no match',-1,S.IndexOfAny(['a','z'],4,3));
|
|
AssertEquals('StartIndex, count, Single char in set, match',4,S.IndexOfAny(['e'],3,4));
|
|
AssertEquals('StartIndex, count, Single char in set, match in range',10,S.IndexOfAny(['e'],5,6));
|
|
AssertEquals('StartIndex, count, 2 chars in set, 2nd matches',3,S.IndexOfAny(['a','b'],2,3));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIndexOfAnyString;
|
|
|
|
Var
|
|
S : String;
|
|
ES : Array of String;
|
|
begin
|
|
S:=TBI;
|
|
ES:=[];
|
|
// Just a set
|
|
SetLength(ES,0);
|
|
AssertEquals('Empty set',-1,S.IndexOfAny(ES));
|
|
AssertEquals('Single string in set, no match',-1,S.IndexOfAny(['ab']));
|
|
AssertEquals('Single string in set, no match (wrong case)',-1,S.IndexOfAny(['TO']));
|
|
AssertEquals('2 strings in set, no match',-1,S.IndexOfAny(['ab','yz']));
|
|
AssertEquals('Single string in set, match',4,S.IndexOfAny(['e ']));
|
|
AssertEquals('2 strings in set, 2nd matches',3,S.IndexOfAny(['ee','be']));
|
|
// Start index
|
|
AssertEquals('StartIndex, Empty set',-1,S.IndexOfAny(ES,2));
|
|
AssertEquals('StartIndex, Single string in set, no match',-1,S.IndexOfAny(['aa'],2));
|
|
AssertEquals('StartIndex, Single string in set, no match (wrong case)',-1,S.IndexOfAny(['TO'],1));
|
|
AssertEquals('StartIndex, Single string in set, no match (index too big)',-1,S.IndexOfAny(['To'],2));
|
|
AssertEquals('StartIndex, 2 strings in set, no match',-1,S.IndexOfAny(['aa','zz'],4));
|
|
AssertEquals('StartIndex, Single string in set, match',4,S.IndexOfAny(['e '],3));
|
|
AssertEquals('StartIndex, 2 strings in set, 2nd matches',3,S.IndexOfAny(['aa','be'],2));
|
|
// Start index, count
|
|
AssertEquals('StartIndex, count, Empty set',-1,S.IndexOfAny(ES,2,3));
|
|
AssertEquals('StartIndex, count, Single string in set, no match',-1,S.IndexOfAny(['aa'],2));
|
|
AssertEquals('StartIndex, count, Single string in set, no match (wrong case)',-1,S.IndexOfAny(['tO'],1));
|
|
AssertEquals('StartIndex, count, Single string in set, no match (index too big)',-1,S.IndexOfAny(['To'],2,4));
|
|
AssertEquals('StartIndex, count, Single string in set, no match (index too big, count too small)',-1,S.IndexOfAny(['To'],5,5));
|
|
AssertEquals('StartIndex, count, 2 strings in set, no match',-1,S.IndexOfAny(['aa','zz'],4,3));
|
|
AssertEquals('StartIndex, count, Single string in set, match',4,S.IndexOfAny(['e '],3,4));
|
|
AssertEquals('StartIndex, count, Single string in set, match in range',10,S.IndexOfAny(['em'],5,7));
|
|
AssertEquals('StartIndex, count, 2 strings in set, 2nd matches',3,S.IndexOfAny(['aa','be'],2,3));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIndexOfUnquoted;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
// Tests created from special cases in Embarcadero docs.
|
|
S:='"Thias" ias iat';
|
|
AssertEquals('Simple case, match',8,S.IndexOfUnquoted('ia','"','"'));
|
|
S:='"This is" it';
|
|
AssertEquals('Simple case, match',10,S.IndexOfUnquoted(' ','"','"'));
|
|
S:='"Thias ias iat';
|
|
AssertEquals('Opening but not closed',-1,S.IndexOfAnyUnquoted(['i','a'],'"','"'));
|
|
S:='"Thias" "ias" "iat"';
|
|
AssertEquals('Only spaces unquoted',-1,S.IndexOfAnyUnquoted(['i','a'],'"','"'));
|
|
S:='<Thias <ias>> iat';
|
|
AssertEquals('Different start/end quotes',14,S.IndexOfAnyUnquoted(['i','a'],'<','>'));
|
|
S:='"Thias" ias iat';
|
|
AssertEquals('Start index',3,S.IndexOfAnyUnquoted(['i','a'],'"','"',1));
|
|
S:='Thias" "ias" "iat';
|
|
AssertEquals('Start index',-1,S.IndexOfAnyUnquoted(['i','a'],'"','"',6));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIndexOfAnyUnquoted;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
// Tests created from special cases in Embarcadero docs.
|
|
S:='"This" is it';
|
|
AssertEquals('Simple case, match',7,S.IndexOfAnyUnquoted(['i'],'"','"'));
|
|
AssertEquals('Simple case 2, match',7,S.IndexOfAnyUnquoted(['a','i'],'"','"'));
|
|
S:='"This is it';
|
|
AssertEquals('Opening but not closed',-1,S.IndexOfAnyUnquoted(['i'],'"','"'));
|
|
S:='"This" "is" "it"';
|
|
AssertEquals('Only spaces unquoted',-1,S.IndexOfAnyUnquoted(['i'],'"','"'));
|
|
S:='<This <is>> it';
|
|
AssertEquals('Different start/end quotes',12,S.IndexOfAnyUnquoted(['i'],'<','>'));
|
|
S:='"This" is it';
|
|
// The documentation is WRONG on this one. Delphi prints 3, not 2 as in the docs.
|
|
AssertEquals('Start index',3,S.IndexOfAnyUnquoted(['i'],'"','"',1));
|
|
S:='This" "is" "it';
|
|
AssertEquals('Start index',-1,S.IndexOfAnyUnquoted(['i'],'"','"',5));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestInsert;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('0 based (1) (result)','All To be implemented',S.Insert(0,'All '));
|
|
AssertEquals('0 based (1) (self)','All To be implemented',S);
|
|
S:=TBI;
|
|
AssertEquals('0 based (2)','To be completely implemented',S.Insert(6,'completely '));
|
|
S:=TBI;
|
|
AssertEquals('Negative index','completely '+TBI,S.Insert(-3,'completely '));
|
|
S:=TBI;
|
|
AssertEquals('Too big index',TBI+'completely ',S.Insert(Length(S)+1,'completely '));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIsDelimiter;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertTrue('Simple case, true',S.IsDelimiter('be',3));
|
|
AssertFalse('Simple case, false',S.IsDelimiter('ba',4));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestIsEmpty;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:='';
|
|
AssertTrue('Simple case, true',S.IsEmpty);
|
|
S:='abc';
|
|
AssertFalse('Simple case, false',S.IsEmpty);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestLastDelimiter;
|
|
|
|
Var
|
|
S : String;
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Simple case, match, zero based ',0,S.LastDelimiter('T'));
|
|
AssertEquals('Simple case, no match ',-1,S.LastDelimiter('a'));
|
|
AssertEquals('Simple case',3,S.LastDelimiter('b'));
|
|
AssertEquals('Simple, check last match ',Length(TBI)-2,S.LastDelimiter('e'));
|
|
AssertEquals('Multi, no match ',-1,S.LastDelimiter('qy'));
|
|
AssertEquals('Multi, last match 1',Length(TBI)-1,S.LastDelimiter('ed'));
|
|
AssertEquals('Multi, last match 2',Length(TBI)-2,S.LastDelimiter('eb'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestLastIndexOf;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Simple case, no match',-1,S.LastIndexOf('a'));
|
|
AssertEquals('Simple case, zero based',0,S.LastIndexOf('T'));
|
|
AssertEquals('Simple case last',Length(TBI)-2,S.LastIndexOf('e'));
|
|
AssertEquals('Simple case, startindex too low',-1,S.LastIndexOf('e',3));
|
|
AssertEquals('Simple case, startindex OK ',4,S.LastIndexOf('e',7));
|
|
AssertEquals('Simple case, startindex OK, count too small ',-1,S.LastIndexOf('e',7,3));
|
|
AssertEquals('Simple case, startindex OK, count border',4,S.LastIndexOf('e',7,4));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestLastIndexOfString;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Simple case, no match',-1,S.LastIndexOf('aa'));
|
|
AssertEquals('Simple case, zero based',0,S.LastIndexOf('To'));
|
|
AssertEquals('Simple case last',Length(TBI)-2,S.LastIndexOf('ed'));
|
|
AssertEquals('Simple case, startindex too low',-1,S.LastIndexOf('ed',3));
|
|
AssertEquals('Simple case, startindex OK ',3,S.LastIndexOf('be',7));
|
|
AssertEquals('Simple case, startindex OK, count too small ',-1,S.LastIndexOf('be',7,3));
|
|
AssertEquals('Simple case, startindex OK, count border',3,S.LastIndexOf('be',7,4));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestLastIndexOfAny;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Simple case, no match',-1,S.LastIndexOfAny(['x']));
|
|
AssertEquals('Double case, no match',-1,S.LastIndexOfAny(['a','x']));
|
|
AssertEquals('Simple case, zero based',0,S.LastIndexOfAny(['T']));
|
|
AssertEquals('Double case, zero based',0,S.LastIndexOfAny(['T','q']));
|
|
AssertEquals('Simple case last',Length(TBI)-2,S.LastIndexOf('e'));
|
|
AssertEquals('Simple case, startindex too low',-1,S.LastIndexOf('e',3));
|
|
AssertEquals('Simple case, startindex OK ',4,S.LastIndexOf('e',7));
|
|
AssertEquals('Simple case, startindex OK, count too small ',-1,S.LastIndexOf('e',7,3));
|
|
AssertEquals('Simple case, startindex OK, count border',4,S.LastIndexOf('e',7,4));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestPadLeft;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:='TBI';
|
|
AssertEquals('Default char',' TBI',S.PadLeft(5));
|
|
AssertEquals('Length reached','TBI',S.PadLeft(3));
|
|
AssertEquals('Length over','TBI',S.PadLeft(2));
|
|
AssertEquals('Alternate char','**TBI',S.PadLeft(5,'*'));
|
|
end;
|
|
Procedure TTestStringHelper.TestPadRight;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:='TBI';
|
|
AssertEquals('Default char','TBI ',S.PadRight(5));
|
|
AssertEquals('Original remains untouched','TBI',S);
|
|
AssertEquals('Length reached','TBI',S.PadRight(3));
|
|
AssertEquals('Original remains untouched','TBI',S);
|
|
AssertEquals('Length over','TBI',S.PadRight(2));
|
|
AssertEquals('Original remains untouched','TBI',S);
|
|
AssertEquals('Alternate char','TBI**',S.PadRight(5,'*'));
|
|
AssertEquals('Original remains untouched','TBI',S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestQuotedString;
|
|
|
|
Const
|
|
TII = '''This'' is it';
|
|
TII2 = '"This" is it';
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Default case',''''+TBI+'''',S.QuotedString);
|
|
AssertEquals('Original remains untouched',TBI,S);
|
|
S:=TII;
|
|
AssertEquals('Quotes present, doubled','''''''This'''' is it''',S.QuotedString);
|
|
AssertEquals('Original remains untouched',TII,S);
|
|
// Other quote char
|
|
S:=TBI;
|
|
AssertEquals('Quote ", Default case','"'+TBI+'"',S.QuotedString('"'));
|
|
AssertEquals('Quote ", Original remains untouched',TBI,S);
|
|
S:=TII2;
|
|
AssertEquals('Quote ", Quotes present, doubled','"""This"" is it"',S.QuotedString('"'));
|
|
AssertEquals('Quote ", Original remains untouched',TII2,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestRemove;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Delete all','',S.Remove(0));
|
|
AssertEquals('Delete all, original unchanged',TBI,S);
|
|
AssertEquals('Delete from index','To',S.Remove(2));
|
|
AssertEquals('Delete all, original unchanged',TBI,S);
|
|
AssertEquals('Delete from negative index',TBI,S.Remove(-1));
|
|
AssertEquals('Delete from negative, original unchanged',TBI,S);
|
|
// Count
|
|
AssertEquals('Delete N from start','be implemented',S.Remove(0,3));
|
|
AssertEquals('Delete all, original unchanged',TBI,S);
|
|
AssertEquals('Delete from start index, count','To implemented',S.Remove(2,3));
|
|
AssertEquals('Delete from start index, count, original unchanged',TBI,S);
|
|
AssertEquals('Delete from negative index, count',TBI,S.Remove(-1,4));
|
|
AssertEquals('Delete from negative index, count, original unchanged',TBI,S);
|
|
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestReplace;
|
|
{
|
|
Function Replace(OldChar: Char; NewChar: Char): string; overload;
|
|
Function Replace(OldChar: Char; NewChar: Char; ReplaceFlags: TReplaceFlags): string; overload;
|
|
Function Replace(const OldValue: string; const NewValue: string): string; overload;
|
|
Function Replace(const OldValue: string; const NewValue: string; ReplaceFlags: TReplaceFlags): string; overload;
|
|
}
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
// Char
|
|
AssertEquals('Simple char','to be implemented',S.Replace('T','t'));
|
|
AssertEquals('Simple char, original unchanged',TBI,S);
|
|
AssertEquals('Simple char is case sensitive',TBI,S.Replace('t','t'));
|
|
AssertEquals('Simple char is replace all','To ba implamantad',S.Replace('e','a'));
|
|
AssertEquals('Simple char, case insensitive','to be implemented',S.Replace('t','t',[rfIgnoreCase]));
|
|
AssertEquals('Simple char, only first','To ba implemented',S.Replace('e','a',[]));
|
|
AssertEquals('Simple char, replace all','To ba implamantad',S.Replace('e','a',[rfReplaceAll]));
|
|
// String
|
|
AssertEquals('Simple string','ta be implemented',S.Replace('To','ta'));
|
|
AssertEquals('Simple string, case sensitive',TBI,S.Replace('to','ta'));
|
|
S:='AB AB';
|
|
AssertEquals('Simple string is replace all','cd cd',S.Replace('AB','cd'));
|
|
S:=TBI;
|
|
AssertEquals('Simple string, case insensitive','to be implemented',S.Replace('to','to',[rfIgnoreCase]));
|
|
S:='AB AB AB';
|
|
AssertEquals('Simple sting, only first','cd AB AB',S.Replace('AB','cd',[]));
|
|
S:='AB AB AB';
|
|
AssertEquals('Simple string, replace all','cd cd cd',S.Replace('AB','cd',[rfReplaceAll]));
|
|
end;
|
|
|
|
Function TTestStringHelper.TestArray(Msg : string; Aexpected : Array of string; AActual : TStringArray) : boolean;
|
|
|
|
Var
|
|
I : integer;
|
|
|
|
begin
|
|
Result:=False;
|
|
AssertEquals(Msg+': Length correct',Length(AExpected),Length(AActual));
|
|
for I:=0 to Length(AExpected)-1 do
|
|
AssertEquals(Msg+': Element '+IntToStr(i)+' correct',AExpected[i],AActual[i]);
|
|
Result:=True;
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestSplit;
|
|
|
|
Const
|
|
TII = '"This is" it' ;
|
|
TII2 = '<This is> it' ;
|
|
TII3 = '<This is> it' ;
|
|
CA: array[0..7] of string = ('F0;F1;F2', ';F1;F2', ';;F2', 'F0;;F2', ';;', 'F0;F1;', 'F0;;', ';F1;');
|
|
|
|
Var
|
|
S : String;
|
|
C: TStringArray;
|
|
|
|
begin
|
|
S:='a b';
|
|
C:=S.Split([' ']);
|
|
TestArray('One letter',['a','b'],C);
|
|
S:=TBI;
|
|
C:=S.Split([' ']);
|
|
TestArray('Simple case',['To','be','implemented'],C);
|
|
C:=S.Split([' '],2);
|
|
TestArray('Simple case, count',['To','be'],C);
|
|
S:=TII;
|
|
C:=S.Split([' ','"']);
|
|
TestArray('Quote and space',['','This','is','','it'],C);
|
|
C:=S.Split([' ','"'],TStringSplitOptions.ExcludeEmpty);
|
|
TestArray('Quote and space, exclude empty',['This','is','it'],C);
|
|
C:=S.Split([' '],2);
|
|
TestArray('Quote and space, count 2',['"This','is"'],C);
|
|
C:=S.Split([' ','"'],2,TStringSplitOptions.ExcludeEmpty);
|
|
TestArray('Quote and space, exclude empty,count 2',['This','is'],C);
|
|
C:=S.Split([' ','"'],1,TStringSplitOptions.ExcludeEmpty);
|
|
TestArray('Quote and space, exclude empty, count 1',['This'],C);
|
|
C:=S.Split([' '],'"','"');
|
|
TestArray('Quoted, space only',['"This is"','it'],C);
|
|
C:=S.Split([' '],'"','"',1);
|
|
TestArray('Quoted, space only; count',['"This is"'],C);
|
|
S:=TII2;
|
|
C:=S.Split([' '],'<','>');
|
|
TestArray('Quoted <>, space only',['<This is>','it'],C);
|
|
S:=TII3;
|
|
C:=S.Split([' '],'<','>');
|
|
TestArray('Quoted <>, space only, have space',['<This is>','','it'],C);
|
|
S:=TII3;
|
|
C:=S.Split([' '],'<','>',TStringSplitOptions.ExcludeEmpty);
|
|
TestArray('Quoted <>, space only, have space, exclude empty',['<This is>','it'],C);
|
|
for S in CA do
|
|
begin
|
|
C := S.Split([';']);
|
|
AssertEquals('Error : expect 3 elements when splitting string '+S,3,Length(C));
|
|
end;
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestSplitString;
|
|
|
|
|
|
Const
|
|
TII = '"This is" it' ;
|
|
TII2 = '<This is> it' ;
|
|
TII3 = '<This is> it' ;
|
|
|
|
Var
|
|
S : String;
|
|
C: TStringArray;
|
|
|
|
begin
|
|
S:=StringReplace(TBI,' ',' ',[rfReplaceAll]);
|
|
{ C:=S.Split([' ']);
|
|
TestArray('Simple case',['To','be','implemented'],C);
|
|
C:=S.Split([' '],2);
|
|
TestArray('Simple case, count',['To','be'],C);
|
|
S:=TII;
|
|
C:=S.Split([' ','"']);
|
|
TestArray('Quote and space',['','This','is','','it'],C);
|
|
C:=S.Split([' ','"'],ExcludeEmpty);
|
|
TestArray('Quote and space, exclude empty',['This','is','it'],C);
|
|
C:=S.Split([' '],2);
|
|
TestArray('Quote and space, count 2',['"This','is"'],C);
|
|
C:=S.Split([' ','"'],2,ExcludeEmpty);
|
|
TestArray('Quote and space, exclude empty,count 2',['This','is'],C);
|
|
C:=S.Split([' ','"'],1,ExcludeEmpty);
|
|
TestArray('Quote and space, exclude empty, count 1',['This'],C);
|
|
}
|
|
S:=TII;
|
|
C:=S.Split([' '],'"','"');
|
|
TestArray('Quoted, space only',['"This is"','it'],C);
|
|
C:=S.Split([' '],'"','"',1);
|
|
TestArray('Quoted, space only; count',['"This is"'],C);
|
|
S:=TII2;
|
|
C:=S.Split([' '],'<','>');
|
|
TestArray('Quoted <>, space only',['<This is>','it'],C);
|
|
S:=TII3;
|
|
C:=S.Split([' '],'<','>');
|
|
TestArray('Quoted <>, space only, have space',['<This is>','','it'],C);
|
|
S:=TII3;
|
|
C:=S.Split([' '],'<','>',TStringSplitOptions.ExcludeEmpty);
|
|
TestArray('Quoted <>, space only, have space, exclude empty',['<This is>','it'],C);
|
|
end;
|
|
|
|
|
|
Procedure TTestStringHelper.TestStartsWith;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertTrue('Match empty',S.StartsWith(''));
|
|
AssertTrue('Match',S.StartsWith('To'));
|
|
AssertFalse('Match, case sensitive',S.StartsWith('to'));
|
|
AssertFalse('No Match',S.StartsWith('ab'));
|
|
AssertFalse('No Match, complete',S.StartsWith('To n'));
|
|
AssertFalse('Match, only start',S.StartsWith('be'));
|
|
AssertTrue('Match, case insensitive',S.StartsWith('To'));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestSubstring;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
// No length
|
|
AssertEquals('0 based','ed',S.SubString(Length(S)-2));
|
|
AssertEquals('0 based, original untouched',TBI,S);
|
|
AssertEquals('Index too big','',S.SubString(Length(S)+2));
|
|
AssertEquals('Index negative',TBI,S.SubString(-1));
|
|
// Length
|
|
AssertEquals('0 based','To',S.SubString(0,2));
|
|
AssertEquals('0 based, original untouched',TBI,S);
|
|
AssertEquals('Index too big','',S.SubString(Length(S)+2,3));
|
|
AssertEquals('Index negative','To',S.SubString(-1,2));
|
|
AssertEquals('Sub, index','be',S.SubString(3,2));
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToCharArray;
|
|
|
|
Var
|
|
S : String;
|
|
C : TCharArray;
|
|
I : integer;
|
|
|
|
begin
|
|
S:=TBI;
|
|
C:=S.ToCharArray;
|
|
AssertEquals('No args, length',Length(S),Length(C));
|
|
For I:=1 to Length(S) do
|
|
AssertEquals('No args, character (1-based) : '+IntToStr(i),S[i],C[i-1]);
|
|
C:=S.ToCharArray(3,Length(S)-3);
|
|
AssertEquals('No args, length',Length(S)-3,Length(C));
|
|
For I:=4 to Length(S) do
|
|
AssertEquals('Args(3,len), character (1-based) : '+IntToStr(i),S[i],C[i-4]);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToLower;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Lowercase','to be implemented',S.ToLower);
|
|
AssertEquals('Lowercase, original unmodified',TBI,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToLowerInvariant;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Lowercase','to be implemented',S.ToLowerInvariant);
|
|
AssertEquals('Lowercase, original unmodified',TBI,S);
|
|
// This probably needs testing of some special cases.
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToUpper;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Lowercase','TO BE IMPLEMENTED',S.ToUpper);
|
|
AssertEquals('Lowercase, original unmodified',TBI,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestToUpperInvariant;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Lowercase','TO BE IMPLEMENTED',S.ToUpperInvariant);
|
|
AssertEquals('Lowercase, original unmodified',TBI,S);
|
|
// This probably needs testing of some special cases.
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestTrim;
|
|
Var
|
|
T,S : String;
|
|
C : Char;
|
|
|
|
begin
|
|
S:=TBI;
|
|
For C:=#0 to #32 do
|
|
S:=C+S+C;
|
|
T:=S;
|
|
AssertEquals('By default all chars below #32 stripped',TBI,S.Trim);
|
|
AssertEquals('Original unmodified',T,S);
|
|
S:='lmn'+TBI+'lmn';
|
|
T:=S;
|
|
AssertEquals('Strip all indicated chars',TBI,S.Trim(['l','m','n']));
|
|
AssertEquals('Strip all indicated chars, Original unmodified',T,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestTrimLeft;
|
|
|
|
Var
|
|
O,T,S : String;
|
|
C : Char;
|
|
|
|
begin
|
|
S:=TBI;
|
|
T:=TBI;
|
|
For C:=#0 to #32 do
|
|
begin
|
|
S:=C+S+C;
|
|
T:=T+C;
|
|
end;
|
|
O:=S;
|
|
AssertEquals('By default all chars below #32 stripped',T,S.TrimLeft);
|
|
AssertEquals('Original unmodified',O,S);
|
|
S:='lmn'+TBI+'lmn';
|
|
T:=TBI+'lmn';
|
|
O:=S;
|
|
AssertEquals('Strip all indicated chars',T,S.TrimLeft(['l','m','n']));
|
|
AssertEquals('Strip all indicated chars, Original unmodified',O,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestTrimRight;
|
|
|
|
Var
|
|
O,T,S : String;
|
|
C : Char;
|
|
|
|
begin
|
|
S:=TBI;
|
|
T:=TBI;
|
|
For C:=#0 to #32 do
|
|
begin
|
|
S:=C+S+C;
|
|
T:=C+T;
|
|
end;
|
|
O:=S;
|
|
AssertEquals('By default all chars below #32 stripped',T,S.TrimRight);
|
|
AssertEquals('Original unmodified',O,S);
|
|
S:='lmn'+TBI+'lmn';
|
|
T:='lmn'+TBI;
|
|
O:=S;
|
|
AssertEquals('Strip all indicated chars',T,S.TrimRight(['l','m','n']));
|
|
AssertEquals('Strip all indicated chars, Original unmodified',O,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestTrimEnd;
|
|
|
|
Var
|
|
O,T,S : String;
|
|
|
|
begin
|
|
S:='lmn'+TBI+'lmn';
|
|
T:='lmn'+TBI;
|
|
O:=S;
|
|
AssertEquals('Strip all indicated chars',T,S.TrimRight(['l','m','n']));
|
|
AssertEquals('Strip all indicated chars, Original unmodified',O,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestTrimStart;
|
|
|
|
Var
|
|
O,T,S : String;
|
|
|
|
begin
|
|
S:='lmn'+TBI+'lmn';
|
|
T:=TBI+'lmn';
|
|
O:=S;
|
|
AssertEquals('Strip all indicated chars',T,S.TrimLeft(['l','m','n']));
|
|
AssertEquals('Strip all indicated chars, Original unmodified',O,S);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestChars;
|
|
|
|
Var
|
|
S : String;
|
|
I : Integer;
|
|
begin
|
|
S:=TBI;
|
|
For I:=1 to Length(S) do
|
|
AssertEquals('Character (1-based)'+IntToStr(i),S[i],S.Chars[i-1]);
|
|
end;
|
|
|
|
Procedure TTestStringHelper.TestLength;
|
|
|
|
Var
|
|
S : String;
|
|
|
|
begin
|
|
S:=TBI;
|
|
AssertEquals('Correct length',Length(TBI),S.Length);
|
|
end;
|
|
|
|
(* // Template code;
|
|
Procedure TTestStringHelper.Test;
|
|
|
|
begin
|
|
Result:='To be implemented';
|
|
end;
|
|
*)
|
|
|
|
Procedure RegisterStringHelperTests;
|
|
|
|
|
|
begin
|
|
RegisterTest(TTestStringHelper);
|
|
end;
|
|
|
|
initialization
|
|
RegisterStringHelperTests;
|
|
end.
|
|
|