Changeset 82

Timestamp:

Feb 25, 2007, 4:15:10 PM (18 years ago)

Author:

RBRi

Message:

file util refactoring and many more unit tests

Location:

trunk/NewView

Files:

• CmdLineParameterUnit.pas (modified) (4 diffs)
• DebugUnit.pas (modified) (1 diff)
• FileDialogForm.pas (modified) (5 diffs)
• FileUtilsUnit.pas (added)
• GlobalSearchForm.pas (modified) (4 diffs)
• MainForm.pas (modified) (8 diffs)
• StartupUnit.pas (modified) (2 diffs)
• StringUtilsUnit.pas (modified) (9 diffs)
• unittests/CmdLineParameterUnitTests.pas (added)
• unittests/CompatibleFileUtilsUnitTests.pas (added)
• unittests/FileUtilsUnitTests.pas (added)
• unittests/NewViewTests.pas (added)
• unittests/StringUtilsUnitTests.pas (modified) (7 diffs)

trunk/NewView/CmdLineParameterUnit.pas

@@ -78 +78 @@
        PROCEDURE logDetails;
        PROCEDURE parseCmdLine(aCmdLineString : String);
-  end;
-
-  FUNCTION getOwnHelpFileName: String;
+       FUNCTION getOwnHelpFileName: String;
+  end;
 
   // returns a string containing the whole
@@ -90 +89 @@
 uses
   DOS,
-  ACLFileUtility;
+  FileUtilsUnit;
 
   PROCEDURE TCmdLineParameters.writeDetailsTo(aStrings : TStrings);
@@ -426 +425 @@
       if fileNames = '' then
       begin
-        tmpOwnHelpFileName := FindDefaultLanguageHelpFile('NewView');
+        tmpOwnHelpFileName := getOwnHelpFileName;
         if FileExists(tmpOwnHelpFileName)
         then
@@ -605 +604 @@
 
 
-  FUNCTION getOwnHelpFileName: String;
+  FUNCTION TCmdLineParameters.getOwnHelpFileName: String;
+  var
+    tmpLanguage : String;
   begin
-    result := FindDefaultLanguageHelpFile('NewView');
+    tmpLanguage := getLanguage;
+    if tmpLanguage = '' then
+    begin
+      tmpLanguage := GetEnv(LanguageEnvironmentVar)
+    end;
+
+    result := FindDefaultLanguageHelpFile('NewView', tmpLanguage);
   end;
 

trunk/NewView/DebugUnit.pas

@@ -60 +60 @@
 
 Implementation
+
 uses
   BseDos,

trunk/NewView/FileDialogForm.pas

@@ -124 +124 @@
   SysUtils,
   ACLStringUtility,
-  ACLFileUtility,
+  FileUtilsUnit,
   ACLDialogs,
   ACLString,
@@ -487 +487 @@
   // (in order to support typing directories, either full or relative)
   Directory := DirectoryListBox.Directory;
-  NewDirectory := ACLFileUtility.ExpandPath( Directory, FileNameText );
+  NewDirectory := ExpandPath( Directory, FileNameText );
 
   DosErrorAPI( FERR_DISABLEHARDERR );
@@ -521 +521 @@
     // Work out directory
     FilePath := ExtractFilePath( FileName );
-    FilePath := ACLFileUtility.ExpandPath( Directory, FilePath );
-
-    FileName := AddSlash( FilePath )
+    FilePath := ExpandPath( Directory, FilePath );
+
+    FileName := AddDirectorySeparator( FilePath )
                 + ExtractFileName( FileName );
     if RequireFileExists then
@@ -592 +592 @@
   DosErrorAPI( FERR_DISABLEHARDERR );
 
-  ListDirectory( DirectoryListBox.Directory,
-                 FileMask,
-                 Filenames,
-                 nil );
+  ListFilesInDirectory( DirectoryListBox.Directory,
+                        FileMask,
+                        Filenames);
 
   Filenames.Sort;
@@ -606 +605 @@
     Filename := Filenames[ i ];
 
-    Title := GetHelpFileTitle( AddSlash( DirectoryListBox.Directory )
+    Title := GetHelpFileTitle( AddDirectorySeparator( DirectoryListBox.Directory )
                                + Filename );
 

trunk/NewView/GlobalSearchForm.pas

@@ -143 +143 @@
   SysUtils,
   DebugUnit,
-  ACLFileUtility,
   ACLDialogs,
   ControlsUtility,
@@ -153 +152 @@
   SearchDirectoriesFormUnit,
   SettingsUnit,
-  InformationFormUnit;
+  InformationFormUnit,
+  FileUtilsUnit;
 
 type
@@ -517 +517 @@
     begin
       Dir := StrLeftWithout( Dir, 3 );
-      ListDirectoryRecursiveAdditive2( Dir,
+      ListFilesInDirectoryRecursiveWithTermination(
+                                       Dir,
                                        '*.inf;*.hlp',
-                                       Dir, // want full paths
                                        Files,
-                                       nil, // don't care to know subdirs
                                        ThreadManager.StopRequested,
                                        true ); // check termination
@@ -527 +526 @@
     else
     begin
-      ListDirectoryAdditive( Dir,
-                             '*.inf;*.hlp',
-                             Dir, // want full paths
-                             Files,
-                             nil ); // don't care to know subdirs
+      ListFilesInDirectory( Dir,
+                            '*.inf;*.hlp',
+                            Files);
     end;
   end;

trunk/NewView/MainForm.pas

@@ -827 +827 @@
   // Library
   ACLStringUtility,
-  ACLFileUtility,
   ACLFileIOUtility,
   ACLUtility,
@@ -834 +833 @@
   StringUtilsUnit,
   DebugUnit,
+
+  FileUtilsUnit,
 
   // Components
@@ -1318 +1319 @@
   DropObject := Source as TExternalDragDropObject;
 
-  g_ExternalLinkFileName := AddSlash( DropObject.ContainerName )
+  g_ExternalLinkFileName := AddDirectorySeparator( DropObject.ContainerName )
                             + DropObject.SourceFilename;
   g_ExternalLinkTopic := '';
@@ -2682 +2683 @@
 begin
   // try in same dir as source file
-  FilePath := AddSlash( ExtractFilePath( g_ExternalLinkSourceFilename ) )
+  FilePath := AddDirectorySeparator( ExtractFilePath( g_ExternalLinkSourceFilename ) )
               + g_ExternalLinkFilename;
 
@@ -3807 +3808 @@
   StartingUp := true;
 
-  Application.HelpFile := GetOwnHelpFilename; // OWN_HELP_MARKER;
-  Application.OnHelp := OnHelp;
-
   SharedMemory := AccessSharedMemory;
   GlobalFilelist := TGlobalFilelist.Create;
@@ -3817 +3815 @@
   CmdLineParameters := TCmdLineParameters.Create;
   CmdLineParameters.parseCmdLine(tmpCmdLine);
+
+  Application.HelpFile := CmdLineParameters.GetOwnHelpFilename; // OWN_HELP_MARKER;
+  Application.OnHelp := OnHelp;
 
   RegisterForLanguages( OnLanguageEvent );
@@ -6485 +6486 @@
 
     // Find the help file, if possible
-    FullFilePath := FindHelpFile( Filename );
+    if Filename = OWN_HELP_MARKER then
+    begin
+      FullFilePath := CmdLineParameters.GetOwnHelpFileName;
+    end
+    else
+    begin
+      FullFilePath := FindHelpFile( Filename );
+    end;
+
     if FullFilePath <> '' then
     begin
@@ -6788 +6797 @@
   if Settings.UseOriginalDialogs then
   begin
-    SystemOpenDialog.Filename := AddSlash( Settings.LastOpenDirectory ) + '*.hlp;*.inf';
+    SystemOpenDialog.Filename := AddDirectorySeparator( Settings.LastOpenDirectory ) + '*.hlp;*.inf';
     if not SystemOpenDialog.Execute then
       exit;

trunk/NewView/StartupUnit.pas

@@ -48 +48 @@
   PMWin,
   ACLStringUtility,
-  ACLFileUtility,
-  HelpManagerUnit;
+  HelpManagerUnit,
+  FileUtilsUnit;
 
 // Look for any items that are actually specifiying environment
@@ -95 +95 @@
   AlternativeFileName: string;
 begin
-  if FileName = OWN_HELP_MARKER then
-  begin
-    Result := GetOwnHelpFileName;
-    exit;
-  end;
-
   Result := '';
 

trunk/NewView/StringUtilsUnit.pas

@@ -45 +45 @@
   //     StrExtractStrings('1x2x3\x4', "x", '\') ->
   //     returns 4 strings: "1", "", "2" and "3x4"
-  Procedure StrExtractStrings(Var aResult : TStringList; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
+  Procedure StrExtractStrings(Var aResult : TStrings; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
+
+  // same as StrExtractStrings but ignores empty strings
+  Procedure StrExtractStringsIgnoreEmpty(Var aResult : TStrings; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
+
+  // removes all occurences of char from aSetOfChars from the beginning
+  // of a String.
+  Function StrTrimLeftChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
+
+  // removes all occurences of char from aSetOfChars from the end
+  // of a String.
+  Function StrTrimRightChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
 
   // removes all occurences of char from aSetOfChars from the beginning
@@ -53 +64 @@
   // removes all blanks from beginning and end
   Function StrTrim(const aReceiver: String): String;
+
+  // Returns the aCount leftmost chars of aString
+  Function StrLeft(const aString : String; const aCount : Integer) : String;
 
   // returns true if the String ends with the provides one
@@ -114 +128 @@
   begin
     result := '';
-    for i := 0 To stringList.count-1 do
+    for i := 0 to stringList.count-1 do
     begin
       if (i > 0) then result := result + '&';
@@ -156 +170 @@
 
 
-  Procedure StrExtractStrings(Var aResult: TStringList; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
+  Procedure PrivateStrExtractStrings(   Var aResult: TStrings;
+                                        const aReceiver: String;
+                                        const aSetOfChars: TSetOfChars;
+                                        const anEscapeChar: char;
+                                        const anIgnoreEmptyFlag : boolean);
   Var
     i : Integer;
@@ -189 +207 @@
           if (tmpChar IN aSetOfChars) then
           begin
-            aResult.add(tmpPart);
+            if (NOT anIgnoreEmptyFlag) OR ('' <> tmpPart) then
+            begin
+              aResult.add(tmpPart);
+            end;
             tmpPart := '';
             i := i + 1;
@@ -199 +220 @@
           end;
     end;
-    aResult.add(tmpPart);
+
+    if (NOT anIgnoreEmptyFlag) OR ('' <> tmpPart) then
+    begin
+      aResult.add(tmpPart);
+    end;
+  end;
+
+
+  Procedure StrExtractStrings(Var aResult: TStrings; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
+  Begin
+    PrivateStrExtractStrings(aResult, aReceiver, aSetOfChars, anEscapeChar, false);
+  end;
+
+
+  Procedure StrExtractStringsIgnoreEmpty(Var aResult: TStrings; Const aReceiver: String; const aSetOfChars: TSetOfChars; const anEscapeChar: char);
+  Begin
+    PrivateStrExtractStrings(aResult, aReceiver, aSetOfChars, anEscapeChar, true);
+  end;
+
+
+  Function StrTrimLeftChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
+  Var
+    i : Longint;
+  Begin
+    i := 1;
+    // mem optimization
+    if aReceiver[i] in aSetOfChars then
+    begin
+      while i <= Length(aReceiver) do
+      begin
+        if aReceiver[i] in aSetOfChars then
+          inc(i)
+        else
+          break;
+      end;
+      result := Copy(aReceiver, i, Length(aReceiver)-i+1);
+    end
+    else
+    begin
+      result := aReceiver;
+    end;
+  end;
+
+
+  Function StrTrimRightChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
+  Var
+    i : Longint;
+  Begin
+    i := Length(aReceiver);
+
+    // mem optimization
+    if aReceiver[i] in aSetOfChars then
+    begin
+      while i > 0 do
+      begin
+        if aReceiver[i] in aSetOfChars then
+          dec(i)
+        else
+          break;
+      end;
+      result := Copy(aReceiver, 1, i);
+    end
+    else
+    begin
+      result := aReceiver;
+    end;
   end;
 
@@ -207 +293 @@
     i : Longint;
     j : Longint;
-  Begin
+    tmpNeedCopy : boolean;
+  Begin
+    tmpNeedCopy := false;
     i := 1;
     while i < Length(aReceiver) do
     begin
       if aReceiver[i] in aSetOfChars then
-        inc(i)
-       else
-         break;
+      begin
+        inc(i);
+        tmpNeedCopy := true;
+      end
+      else
+      begin
+        break;
+      end;
     end;
 
@@ -221 +314 @@
     begin
       if aReceiver[j] in aSetOfChars then
-        dec(j)
+      begin
+        dec(j);
+        tmpNeedCopy := true;
+      end
       else
+      begin
         break;
-    end;
-
-    result := Copy(aReceiver, i, j-i+1);
+      end;
+    end;
+
+    if tmpNeedCopy then
+    begin
+      result := Copy(aReceiver, i, j-i+1);
+    end
+    else
+    begin
+      result := aReceiver;
+    end;
   end;
 
@@ -233 +338 @@
   Begin
     result := StrTrimChars(aReceiver, [' ']);
+  end;
+
+
+  Function StrLeft(const aString : String; const aCount : Integer) : String;
+  Begin
+    if aCount >= Length(aString) then
+      Result := aString
+    else
+      Result := copy(aString, 1, aCount);
   end;
 

trunk/NewView/unittests/StringUtilsUnitTests.pas

@@ -8 +8 @@
   StringUtilsUnit;
 
- FUNCTION getStringUtilsUnitTests : TList;
+  FUNCTION getStringUtilsUnitTests : TList;
 
 
@@ -279 +279 @@
 
 
+  // ------------------------------------------------------
+
+
   PROCEDURE testStrExtractStrings_EmptyReceiver;
   VAR
@@ -408 +411 @@
 
 
+  // ------------------------------------------------------
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyReceiver;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, '', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyReceiver', 0, tmpResult.count);
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_OnlyOnePart;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'abcd', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 1, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_OnlyOnePart', 'abcd', tmpResult[0]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_ManyParts;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'abxcd', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_ManyParts', 2, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'ab', tmpResult[0]);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_ManyParts', 'cd', tmpResult[1]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_StartWithDelimiter;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'xab', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 1, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_StartWithDelimiter', 'ab', tmpResult[0]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_EndWithDelimiter;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'abx', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 1, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_EndWithDelimiter', 'ab', tmpResult[0]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_EmptyPartInside;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 2, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'a', tmpResult[0]);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_EmptyPartInside', 'b', tmpResult[1]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_NoDelimiter;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'axxb', [], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_NoDelimiter', 1, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_NoDelimiter', 'axxb', tmpResult[0]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedDelimiter;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'a\xb', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 1, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedDelimiter', 'axb', tmpResult[0]);
+
+    tmpResult.Destroy;
+  END;
+
+  PROCEDURE testStrExtractStringsIgnoreEmpty_EscapedEscapeChar;
+  VAR
+    tmpResult : TStringList;
+  BEGIN
+    tmpResult := TStringList.Create;
+    StrExtractStringsIgnoreEmpty(tmpResult, 'a\\xb', ['x'], '\');
+
+    assertEqualsInt('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 2, tmpResult.count);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'a\', tmpResult[0]);
+    assertEqualsString('testStrExtractStringsIgnoreEmpty_EscapedEscapeChar', 'b', tmpResult[1]);
+
+    tmpResult.Destroy;
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testTrimLeftChars_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimLeftChars('', ['b', 'x']);
+
+    assertEqualsString('testTrimLeftChars_Empty', '', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimLeftChars_RemoveAll;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimLeftChars('bxxxbx', ['b', 'x']);
+
+    assertEqualsString('testTrimLeftChars_RemoveAll', '', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimLeftChars_OneLeft;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimLeftChars('bxy', ['b', 'x']);
+
+    assertEqualsString('testTrimLeftChars_OneLeft', 'y', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimLeftChars_LeftOnly;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimLeftChars('bxbxxay', ['b', 'x']);
+
+    assertEqualsString('testTrimLeftChars_LeftOnly', 'ay', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimLeftChars_CharsInside;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimLeftChars('bxabxvvx', ['b', 'x']);
+
+    assertEqualsString('testTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimLeftChars_Nothing;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimLeftChars('acdef', ['b', 'x']);
+
+    assertEqualsString('testTrimLeftChars_Nothing', 'acdef', tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testTrimRightChars_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimRightChars('', ['b', 'x']);
+
+    assertEqualsString('testTrimRightChars_Empty', '', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimRightChars_RemoveAll;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimRightChars('bxxxbx', ['b', 'x']);
+
+    assertEqualsString('testTrimRightChars_RemoveAll', '', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimRightChars_OneLeft;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimRightChars('ybx', ['b', 'x']);
+
+    assertEqualsString('testTrimRightChars_OneLeft', 'y', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimRightChars_RightOnly;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimRightChars('aybxbxx', ['b', 'x']);
+
+    assertEqualsString('testTrimRightChars_RightOnly', 'ay', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimRightChars_CharsInside;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimRightChars('abxvvxb', ['b', 'x']);
+
+    assertEqualsString('testTrimRightChars_CharsInside', 'abxvv', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimRightChars_Nothing;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimRightChars('acdef', ['b', 'x']);
+
+    assertEqualsString('testTrimRightChars_Nothing', 'acdef', tmpResult);
+  END;
+
+
+  // -------------------------------------------------------------------
+
   PROCEDURE testTrimChars_Empty;
   VAR
@@ -428 +688 @@
 
 
+  PROCEDURE testTrimChars_OneLeftFromLeft;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimChars('bxa', ['b', 'x']);
+
+    assertEqualsString('testTrimChars_OneLeftFromLeft', 'a', tmpResult);
+  END;
+
+
+  PROCEDURE testTrimChars_OneLeftFromRight;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrTrimChars('abx', ['b', 'x']);
+
+    assertEqualsString('testTrimChars_OneLeftFromRight', 'a', tmpResult);
+  END;
+
+
   PROCEDURE testTrimChars_LeftOnly;
   VAR
@@ -468 +748 @@
 
 
+  // -------------------------------------------------------------------
+
+
   PROCEDURE testTrim;
   VAR
@@ -476 +759 @@
     assertEqualsString('testTrim', 'a bc', tmpResult);
   END;
+
+
+  // -------------------------------------------------------------------
+
+
+  PROCEDURE testStrLeft_Empty;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeft('', 1);
+
+    assertEqualsString('testStrLeft_Empty', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeft_Nothing;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeft('abc', 0);
+
+    assertEqualsString('testStrLeft_Nothing', '', tmpResult);
+  END;
+
+
+  PROCEDURE testStrLeft_WholeString;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeft('abc', 3);
+
+    assertEqualsString('testStrLeft_WholeString', 'abc', tmpResult);
+  END;
+
+  PROCEDURE testStrLeft_ToManyRequested;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeft('abc', 5);
+
+    assertEqualsString('testStrLeft_ToManyRequested', 'abc', tmpResult);
+  END;
+
+  PROCEDURE testStrLeft_Part;
+  VAR
+    tmpResult : String;
+  BEGIN
+    tmpResult := StrLeft('abcdef', 2);
+
+    assertEqualsString('testStrLeft_Part', 'ab', tmpResult);
+  END;
+
+  // -------------------------------------------------------------------
 
 
@@ -724 +1060 @@
     result.add(@testStrExtractStrings_EscapedEscapeChar);
 
+    result.add(@testStrExtractStringsIgnoreEmpty_EmptyReceiver);
+    result.add(@testStrExtractStringsIgnoreEmpty_OnlyOnePart);
+    result.add(@testStrExtractStringsIgnoreEmpty_ManyParts);
+    result.add(@testStrExtractStringsIgnoreEmpty_StartWithDelimiter);
+    result.add(@testStrExtractStringsIgnoreEmpty_EndWithDelimiter);
+    result.add(@testStrExtractStringsIgnoreEmpty_EmptyPartInside);
+    result.add(@testStrExtractStringsIgnoreEmpty_NoDelimiter);
+    result.add(@testStrExtractStringsIgnoreEmpty_EscapedDelimiter);
+    result.add(@testStrExtractStringsIgnoreEmpty_EscapedEscapeChar);
+
+    result.add(@testTrimLeftChars_Empty);
+    result.add(@testTrimLeftChars_RemoveAll);
+    result.add(@testTrimLeftChars_OneLeft);
+    result.add(@testTrimLeftChars_LeftOnly);
+    result.add(@testTrimLeftChars_CharsInside);
+    result.add(@testTrimLeftChars_Nothing);
+
+    result.add(@testTrimRightChars_Empty);
+    result.add(@testTrimRightChars_RemoveAll);
+    result.add(@testTrimRightChars_OneLeft);
+    result.add(@testTrimRightChars_RightOnly);
+    result.add(@testTrimRightChars_CharsInside);
+    result.add(@testTrimRightChars_Nothing);
+
     result.add(@testTrimChars_Empty);
     result.add(@testTrimChars_RemoveAll);
+    result.add(@testTrimChars_OneLeftFromLeft);
+    result.add(@testTrimChars_OneLeftFromRight);
     result.add(@testTrimChars_LeftOnly);
     result.add(@testTrimChars_RightOnly);
     result.add(@testTrimChars_CharsInside);
     result.add(@testTrimChars_Nothing);
+
     result.add(@testTrim);
+
+    result.add(@testStrLeft_Empty);
+    result.add(@testStrLeft_Nothing);
+    result.add(@testStrLeft_WholeString);
+    result.add(@testStrLeft_ToManyRequested);
+    result.add(@testStrLeft_Part);
 
     result.add(@testStrEndsWith_BothEmpty);