Changeset 110


Ignore:
Timestamp:
Apr 25, 2007, 10:26:44 AM (18 years ago)
Author:
RBRi
Message:

AnsiString functins added

Location:
trunk/NewView
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/NewView/StringUtilsUnit.pas

    r106 r110  
    55// This software is released under the GNU Public License - see readme.txt
    66
    7 // Helper functions to work with strings
     7// Helper functions to work with String and AnsiString
    88
    99Interface
    1010
    1111uses
    12  Classes;
     12  Classes,
     13  CharUtilsUnit;
    1314
    1415const
    15   StrTAB = chr(9);
    16   StrCR = chr(13);
    17   StrLF = chr(10);
     16  StrTAB = CharTAB;
     17  StrCR = CharCR;
     18  StrLF = CharLF;
    1819  StrCRLF = StrCR + StrLF;
    1920  StrSingleQuote = '''';
    … …  
    3637  end;
    3738
    38   TYPE
    39     TSetOfChars = set of char;
    40 
    4139  // prefices all occurences of one of the chars in aStringWithChars with anEscape char
    4240  // if the escapeChar itself is found, then it is doubled
    … …  
    110108  // use double quotes if you need blanks in the strings
    111109  Procedure StrExtractStringsQuoted(Var aResult: TStrings; const aReceiver: String );
     110
     111
     112  // returns the position of aPart in aString
     113  // case insensitive
     114  Function CaseInsensitivePos(const aPart: String; const aString: String ): longint;
     115
     116  // --------------------
     117  // ---- AnsiString ----
     118  // --------------------
     119
     120 
     121  // removes all occurences of char from aSetOfChars from the beginning
     122  // of a String.
     123  Function AnsiStrTrimLeftChars(const aReceiver: AnsiString; const aSetOfChars: TSetOfChars): AnsiString;
     124
     125  // removes all occurences of char from aSetOfChars from the end
     126  // of a String.
     127  Function AnsiStrTrimRightChars(const aReceiver: AnsiString; const aSetOfChars: TSetOfChars): AnsiString;
     128
     129  // removes all occurences of char from aSetOfChars from the beginning
     130  // end the end of a String.
     131  Function AnsiStrTrimChars(const aReceiver: AnsiString; const aSetOfChars: TSetOfChars): AnsiString;
     132
     133  // removes all blanks from beginning and end
     134  Function AnsiStrTrim(const aReceiver: AnsiString): AnsiString;
     135
     136
     137
    112138
    113139Implementation
    … …  
    270296  Function StrTrimLeftChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
    271297  Var
    272     i : Longint;
    273   Begin
     298    tmpLength : integer;
     299    i : integer;
     300  Begin
     301    tmpLength := Length(aReceiver);
     302
     303    if 1 > tmpLength then
     304    begin
     305      result := aReceiver;
     306      exit;
     307    end;
     308
    274309    i := 1;
    275310    // mem optimization
    276311    if aReceiver[i] in aSetOfChars then
    277312    begin
    278       while i <= Length(aReceiver) do
     313      while i <= tmpLength do
    279314      begin
    280315        if aReceiver[i] in aSetOfChars then
    … …  
    294329  Function StrTrimRightChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
    295330  Var
    296     i : Longint;
     331    i : integer;
    297332  Begin
    298333    i := Length(aReceiver);
     334
     335    if 1 > i then
     336    begin
     337      result := aReceiver;
     338      exit;
     339    end;
    299340
    300341    // mem optimization
    … …  
    319360  Function StrTrimChars(const aReceiver: String; const aSetOfChars: TSetOfChars): String;
    320361  Var
    321     i : Longint;
    322     j : Longint;
     362    i,j : integer;
    323363    tmpNeedCopy : boolean;
    324364  Begin
     365    j := Length(aReceiver);
     366
     367    if 1 > j then
     368    begin
     369      result := aReceiver;
     370      exit;
     371    end;
     372
    325373    tmpNeedCopy := false;
    326374    i := 1;
    327     while i < Length(aReceiver) do
     375    while i < j do
    328376    begin
    329377      if aReceiver[i] in aSetOfChars then
    … …  
    338386    end;
    339387
    340     j := Length(aReceiver);
    341388    while j >= i do
    342389    begin
    … …  
    701748    end;
    702749  end;
     750
     751
     752  Function CaseInsensitivePos(const aPart: String; const aString: String) : longint;
     753  Var
     754    EndOfPart: longword;
     755  Begin
     756    // Result := Pos(UpperCase(aPart), Uppercase(aString));
     757
     758    // Aarons assembler version :-)
     759    Asm
     760    //Locals:
     761    //a at [EBP+12]
     762    //b at [EBP+8]
     763
     764    // First get and check lengths
     765    MOV   ESI, aPart     // get address of aPart into ESI
     766    MOV   CL,  [ESI]     // get length of aPart
     767    CMP   CL, 0          // if aPart is empty then return null to simulate the behavior of POS
     768    JE    !CIP_NoMatch
     769
     770    MOV   EDI, aString   // get address of aString into EDI
     771    MOV   DL,  [EDI]     // get length of aString
     772    CMP   CL,  DL
     773    JBE   !CIP_PartFitsInString
     774
     775    // aParta longer than aString so aPart can't be in aString
     776
     777    !CIP_NoMatch:
     778      MOV   EAX, 0
     779      LEAVE
     780      RETN32 8
     781
     782    !CIP_PartFitsInString:
     783      INC   ESI            // skip length byte in aPart
     784      INC   EDI            // skip length byte of aString
     785
     786    // get ending address of b into EDX
     787      MOVZX EDX, DL        // widen DL
     788      ADD   EDX, EDI       // add start of aString
     789
     790    // get ending address of a into EndOfA
     791      MOVZX ECX, CL        // widen CL
     792      ADD   ECX, ESI       // add start of aPart
     793      MOV   EndOfPart, ECX    // store to EndOfPart
     794
     795      MOV   ECX, EDI       // set start of current match to start of b
     796
     797      // ESI: current search point in a
     798      // EDI: current search point in b
     799      // EDX: end of b
     800      // ECX: start of current match
     801      // available: eax, ebx
     802
     803      JMP   !CIP_Loop
     804
     805    !CIP_LoopStart:
     806      CMP   EDI, EDX
     807      JE    !CIP_NoMatch   // run out of b
     808
     809      MOV   AL,  [ESI]     // get next char of a
     810      INC   ESI            // next in a
     811
     812      MOV   BL,  [EDI]     // get next char of b
     813      INC   EDI            // next in b
     814
     815    // Convert chars to uppercase
     816      CMP   AL,  97
     817      JB    !CIP_Upcase1
     818      CMP   AL,  122
     819      JA    !CIP_Upcase1
     820      SUB   AL,  32         // convert lower to upper
     821    !CIP_Upcase1:
     822
     823      CMP   BL,97
     824      JB    !CIP_Upcase2
     825      CMP   BL,122
     826      JA    !CIP_Upcase2
     827      SUB   BL,32          // convert lower to upper
     828    !CIP_Upcase2:
     829
     830    // Compare uppercased chars
     831      CMP   AL,BL
     832      JE    !CIP_Loop
     833
     834    // different.
     835
     836    // Back to start of match + 1
     837      INC   ECX            // inc start of match
     838      MOV   EDI, ECX       // back to start of match in b
     839      MOV   ESI, aPart     // back to start of aPart
     840      INC   ESI            // skip length
     841      JMP   !CIP_LoopStart
     842
     843    !CIP_Loop:
     844
     845    // same
     846      CMP   ESI, EndOfPart    // have we reached the end of a
     847      JB    !CIP_LoopStart
     848
     849      // Match, return position
     850      SUB   ECX, [EBP+8]   // position = ( start of match ) - ( start of b ) + 1
     851      MOV   EAX, ECX
     852      LEAVE
     853      RETN32 8
     854    end;
     855  end;
     856
     857
     858  // --------------------
     859  // ---- AnsiString ----
     860  // --------------------
     861
     862
     863  Function AnsiStrTrimLeftChars(const aReceiver: AnsiString; const aSetOfChars: TSetOfChars): AnsiString;
     864  Var
     865    tmpLength : integer;
     866    i : integer;
     867  Begin
     868    tmpLength := Length(aReceiver);
     869
     870    if 1 > tmpLength then
     871    begin
     872      result := aReceiver;
     873      exit;
     874    end;
     875
     876    i := 1;
     877    // mem optimization
     878    if aReceiver[i] in aSetOfChars then
     879    begin
     880      while i <= tmpLength do
     881      begin
     882        if aReceiver[i] in aSetOfChars then
     883          inc(i)
     884        else
     885          break;
     886      end;
     887      result := AnsiCopy(aReceiver, i, Length(aReceiver)-i+1);
     888    end
     889    else
     890    begin
     891      result := aReceiver;
     892    end;
     893  end;
     894
     895
     896  Function AnsiStrTrimRightChars(const aReceiver: AnsiString; const aSetOfChars: TSetOfChars): AnsiString;
     897  Var
     898    i : integer;
     899  Begin
     900    i := Length(aReceiver);
     901
     902    if 1 > i then
     903    begin
     904      result := aReceiver;
     905      exit;
     906    end;
     907
     908    // mem optimization
     909    if aReceiver[i] in aSetOfChars then
     910    begin
     911      while i > 0 do
     912      begin
     913        if aReceiver[i] in aSetOfChars then
     914          dec(i)
     915        else
     916          break;
     917      end;
     918      result := AnsiCopy(aReceiver, 1, i);
     919    end
     920    else
     921    begin
     922      result := aReceiver;
     923    end;
     924  end;
     925
     926
     927  Function AnsiStrTrimChars(const aReceiver: AnsiString; const aSetOfChars: TSetOfChars): AnsiString;
     928  Var
     929    i,j : integer;
     930    tmpNeedCopy : boolean;
     931  Begin
     932    tmpNeedCopy := false;
     933
     934    j := Length(aReceiver);
     935
     936    if 1 > j then
     937    begin
     938      result := aReceiver;
     939      exit;
     940    end;
     941
     942    i := 1;
     943    while i < j do
     944    begin
     945      if aReceiver[i] in aSetOfChars then
     946      begin
     947        inc(i);
     948        tmpNeedCopy := true;
     949      end
     950      else
     951      begin
     952        break;
     953      end;
     954    end;
     955
     956    while j >= i do
     957    begin
     958      if aReceiver[j] in aSetOfChars then
     959      begin
     960        dec(j);
     961        tmpNeedCopy := true;
     962      end
     963      else
     964      begin
     965        break;
     966      end;
     967    end;
     968
     969    if tmpNeedCopy then
     970    begin
     971      result := AnsiCopy(aReceiver, i, j-i+1);
     972    end
     973    else
     974    begin
     975      result := aReceiver;
     976    end;
     977  end;
     978
     979
     980  Function AnsiStrTrim(const aReceiver: AnsiString): AnsiString;
     981  Begin
     982    result := AnsiStrTrimChars(aReceiver, [' ']);
     983  end;
     984
     985
    703986END.

  • trunk/NewView/unittests/StringUtilsUnitTests.pas

    r106 r110  
    55uses
    66  Classes,
     7  SysUtils,
    78  TestAssert,
    89  StringUtilsUnit;
    … …  
    16751676  // ----------------------------------------------------------
    16761677
     1678
     1679  PROCEDURE testCaseInsensitivePos_Empty;
     1680  VAR
     1681    tmpResult : longint;
     1682  BEGIN
     1683    tmpResult := CaseInsensitivePos('', '');
     1684
     1685    assertEqualsInt('testCaseInsensitivePos_Empty', Pos('', ''), tmpResult);
     1686  END;
     1687
     1688
     1689  PROCEDURE testCaseInsensitivePos_EmptyPart;
     1690  VAR
     1691    tmpResult : longint;
     1692  BEGIN
     1693    tmpResult := CaseInsensitivePos('', 'abc');
     1694
     1695    assertEqualsInt('testCaseInsensitivePos_EmptyPart', Pos('', 'abc'), tmpResult);
     1696  END;
     1697
     1698
     1699  PROCEDURE testCaseInsensitivePos_EmptyString;
     1700  VAR
     1701    tmpResult : longint;
     1702  BEGIN
     1703    tmpResult := CaseInsensitivePos('abc', '');
     1704
     1705    assertEqualsInt('testCaseInsensitivePos_EmptyString', Pos('abc', ''), tmpResult);
     1706  END;
     1707
     1708
     1709  PROCEDURE testCaseInsensitivePos_PartLarger;
     1710  VAR
     1711    tmpResult : longint;
     1712  BEGIN
     1713    tmpResult := CaseInsensitivePos('abc', 'ab');
     1714
     1715    assertEqualsInt('testCaseInsensitivePos_PartLarger', Pos('abc', 'ab'), tmpResult);
     1716  END;
     1717
     1718
     1719  PROCEDURE testCaseInsensitivePos_AtLeft;
     1720  VAR
     1721    tmpResult : integer;
     1722  BEGIN
     1723    tmpResult := CaseInsensitivePos('abCd', 'aBcDef');
     1724
     1725    assertEqualsInt('testCaseInsensitivePos_AtLeft', Pos('abcd', 'abcdef'), tmpResult);
     1726  END;
     1727
     1728
     1729  PROCEDURE testCaseInsensitivePos_Middle;
     1730  VAR
     1731    tmpResult : integer;
     1732  BEGIN
     1733    tmpResult := CaseInsensitivePos('abCd', '12aBcDef');
     1734
     1735    assertEqualsInt('testCaseInsensitivePos_Middle', Pos('abcd', '12abcdef'), tmpResult);
     1736  END;
     1737
     1738
     1739  PROCEDURE testCaseInsensitivePos_AtRight;
     1740  VAR
     1741    tmpResult : integer;
     1742  BEGIN
     1743    tmpResult := CaseInsensitivePos('abCd', 'efaBcD');
     1744
     1745    assertEqualsInt('testCaseInsensitivePos_AtRight', Pos('abcd', 'efabcd'), tmpResult);
     1746  END;
     1747
     1748
     1749  PROCEDURE testCaseInsensitivePos;
     1750  VAR
     1751    tmpPart : String;
     1752    tmpString : String;
     1753    tmpResult,i : integer;
     1754  BEGIN
     1755    tmpPart := '';
     1756    tmpString := '';
     1757
     1758    for i:=1 to 255 do
     1759    begin
     1760      tmpPart := tmpPart + char(i);
     1761      tmpString := tmpString + char(i);
     1762    end;
     1763
     1764    tmpResult := CaseInsensitivePos(tmpPart, UpperCase(tmpString));
     1765    assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
     1766
     1767    tmpResult := CaseInsensitivePos(UpperCase(tmpPart), tmpString);
     1768    assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
     1769
     1770    tmpResult := CaseInsensitivePos(tmpPart, LowerCase(tmpString));
     1771    assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
     1772
     1773    tmpResult := CaseInsensitivePos(LowerCase(tmpPart), tmpString);
     1774    assertEqualsInt('testCaseInsensitivePos', 1, tmpResult);
     1775END;
     1776
     1777
     1778  // --------------------
     1779  // ---- AnsiString ----
     1780  // --------------------
     1781
     1782
     1783  PROCEDURE testAnsiTrimLeftChars_Empty;
     1784  VAR
     1785    tmpResult : AnsiString;
     1786    tmpValue : AnsiString;
     1787  BEGIN
     1788    tmpValue := '';
     1789    tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
     1790
     1791    assertEqualsAnsiString('testAnsiTrimLeftChars_Empty', '', tmpResult);
     1792  END;
     1793
     1794
     1795  PROCEDURE testAnsiTrimLeftChars_RemoveAll;
     1796  VAR
     1797    tmpResult : AnsiString;
     1798    tmpValue : AnsiString;
     1799  BEGIN
     1800    tmpValue := 'bxxxbx';
     1801    tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
     1802
     1803    assertEqualsAnsiString('testAnsiTrimLeftChars_RemoveAll', '', tmpResult);
     1804  END;
     1805
     1806
     1807  PROCEDURE testAnsiTrimLeftChars_OneLeft;
     1808  VAR
     1809    tmpResult : AnsiString;
     1810    tmpValue : AnsiString;
     1811  BEGIN
     1812    tmpValue := 'bxy';
     1813    tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
     1814
     1815    assertEqualsAnsiString('testAnsiTrimLeftChars_OneLeft', 'y', tmpResult);
     1816  END;
     1817
     1818
     1819  PROCEDURE testAnsiTrimLeftChars_LeftOnly;
     1820  VAR
     1821    tmpResult : AnsiString;
     1822    tmpValue : AnsiString;
     1823  BEGIN
     1824    tmpValue := 'bxbxxay';
     1825    tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
     1826
     1827    assertEqualsAnsiString('testAnsiTrimLeftChars_LeftOnly', 'ay', tmpResult);
     1828  END;
     1829
     1830
     1831  PROCEDURE testAnsiTrimLeftChars_CharsInside;
     1832  VAR
     1833    tmpResult : AnsiString;
     1834    tmpValue : AnsiString;
     1835  BEGIN
     1836    tmpValue := 'bxabxvvx';
     1837    tmpResult := AnsiStrTrimLeftChars(tmpValue, ['b', 'x']);
     1838
     1839    assertEqualsAnsiString('testAnsiTrimLeftChars_CharsInside', 'abxvvx', tmpResult);
     1840  END;
     1841
     1842
     1843  PROCEDURE testAnsiTrimLeftChars_Nothing;
     1844  VAR
     1845    tmpResult : AnsiString;
     1846    tmpValue : AnsiString;
     1847  BEGIN
     1848    tmpValue := 'acdef';
     1849    tmpResult := AnsiStrTrimLeftChars('acdef', ['b', 'x']);
     1850
     1851    assertEqualsAnsiString('testAnsiTrimLeftChars_Nothing', 'acdef', tmpResult);
     1852  END;
     1853
     1854
     1855  PROCEDURE testAnsiTrimLeftChars_ReallyLong;
     1856  VAR
     1857    tmpResult : AnsiString;
     1858    tmpValue : AnsiString;
     1859  BEGIN
     1860    tmpValue := '0123456789';
     1861    tmpValue := tmpValue + tmpValue;
     1862    tmpValue := tmpValue + tmpValue;
     1863    tmpValue := tmpValue + tmpValue;
     1864    tmpValue := tmpValue + tmpValue;
     1865    tmpValue := tmpValue + tmpValue;
     1866    assertEqualsInt('testAnsiTrimLeftChars_ReallyLong', 320, Length(tmpValue));
     1867
     1868    tmpResult := AnsiStrTrimLeftChars(tmpValue, ['0', '1']);
     1869
     1870    assertEqualsInt('testAnsiTrimLeftChars_ReallyLong', 318, Length(tmpResult));
     1871  END;
     1872
     1873
     1874  // -------------------------------------------------------------------
     1875
     1876
     1877  PROCEDURE testAnsiTrimRightChars_Empty;
     1878  VAR
     1879    tmpResult : AnsiString;
     1880    tmpValue : AnsiString;
     1881  BEGIN
     1882    tmpValue := '';
     1883    tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
     1884
     1885    assertEqualsAnsiString('testAnsiTrimRightChars_Empty', '', tmpResult);
     1886  END;
     1887
     1888
     1889  PROCEDURE testAnsiTrimRightChars_RemoveAll;
     1890  VAR
     1891    tmpResult : AnsiString;
     1892    tmpValue : AnsiString;
     1893  BEGIN
     1894    tmpValue := 'bxxxbx';
     1895    tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
     1896
     1897    assertEqualsAnsiString('testAnsiTrimRightChars_RemoveAll', '', tmpResult);
     1898  END;
     1899
     1900
     1901  PROCEDURE testAnsiTrimRightChars_OneLeft;
     1902  VAR
     1903    tmpResult : AnsiString;
     1904    tmpValue : AnsiString;
     1905  BEGIN
     1906    tmpValue := 'ybx';
     1907    tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
     1908
     1909    assertEqualsAnsiString('testAnsiTrimRightChars_OneLeft', 'y', tmpResult);
     1910  END;
     1911
     1912
     1913  PROCEDURE testAnsiTrimRightChars_RightOnly;
     1914  VAR
     1915    tmpResult : AnsiString;
     1916    tmpValue : AnsiString;
     1917  BEGIN
     1918    tmpValue := 'aybxbxx';
     1919    tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
     1920
     1921    assertEqualsAnsiString('testAnsiTrimRightChars_RightOnly', 'ay', tmpResult);
     1922  END;
     1923
     1924
     1925  PROCEDURE testAnsiTrimRightChars_CharsInside;
     1926  VAR
     1927    tmpResult : AnsiString;
     1928    tmpValue : AnsiString;
     1929  BEGIN
     1930    tmpValue := 'abxvvxb';
     1931    tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
     1932
     1933    assertEqualsAnsiString('testAnsiTrimRightChars_CharsInside', 'abxvv', tmpResult);
     1934  END;
     1935
     1936
     1937  PROCEDURE testAnsiTrimRightChars_Nothing;
     1938  VAR
     1939    tmpResult : AnsiString;
     1940    tmpValue : AnsiString;
     1941  BEGIN
     1942    tmpValue := 'acdef';
     1943    tmpResult := AnsiStrTrimRightChars(tmpValue, ['b', 'x']);
     1944
     1945    assertEqualsAnsiString('testAnsiTrimRightChars_Nothing', 'acdef', tmpResult);
     1946  END;
     1947
     1948
     1949  PROCEDURE testAnsiTrimRightChars_ReallyLong;
     1950  VAR
     1951    tmpResult : AnsiString;
     1952    tmpValue : AnsiString;
     1953  BEGIN
     1954    tmpValue := '0123456789';
     1955    tmpValue := tmpValue + tmpValue;
     1956    tmpValue := tmpValue + tmpValue;
     1957    tmpValue := tmpValue + tmpValue;
     1958    tmpValue := tmpValue + tmpValue;
     1959    tmpValue := tmpValue + tmpValue;
     1960    assertEqualsInt('testAnsiTrimRightChars_ReallyLong', 320, Length(tmpValue));
     1961
     1962    tmpResult := AnsiStrTrimRightChars(tmpValue, ['8', '9']);
     1963
     1964    assertEqualsInt('testAnsiTrimRightChars_ReallyLong', 318, Length(tmpResult));
     1965  END;
     1966
     1967
     1968  // -------------------------------------------------------------------
     1969
     1970  PROCEDURE testAnsiTrimChars_Empty;
     1971  VAR
     1972    tmpResult : AnsiString;
     1973    tmpValue : AnsiString;
     1974  BEGIN
     1975    tmpValue := '';
     1976    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     1977
     1978    assertEqualsAnsiString('testAnsiTrimChars_Empty', '', tmpResult);
     1979  END;
     1980
     1981
     1982  PROCEDURE testAnsiTrimChars_RemoveAll;
     1983  VAR
     1984    tmpResult : AnsiString;
     1985    tmpValue : AnsiString;
     1986  BEGIN
     1987    tmpValue := 'bxxxbx';
     1988    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     1989
     1990    assertEqualsAnsiString('testAnsiTrimChars_RemoveAll', '', tmpResult);
     1991  END;
     1992
     1993
     1994  PROCEDURE testAnsiTrimChars_OneLeftFromLeft;
     1995  VAR
     1996    tmpResult : AnsiString;
     1997    tmpValue : AnsiString;
     1998  BEGIN
     1999    tmpValue := 'bxa';
     2000    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     2001
     2002    assertEqualsAnsiString('testAnsiTrimChars_OneLeftFromLeft', 'a', tmpResult);
     2003  END;
     2004
     2005
     2006  PROCEDURE testAnsiTrimChars_OneLeftFromRight;
     2007  VAR
     2008    tmpResult : AnsiString;
     2009    tmpValue : AnsiString;
     2010  BEGIN
     2011    tmpValue := 'abx';
     2012    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     2013
     2014    assertEqualsAnsiString('testAnsiTrimChars_OneLeftFromRight', 'a', tmpResult);
     2015  END;
     2016
     2017
     2018  PROCEDURE testAnsiTrimChars_LeftOnly;
     2019  VAR
     2020    tmpResult : AnsiString;
     2021    tmpValue : AnsiString;
     2022  BEGIN
     2023    tmpValue := 'bxbxxay';
     2024    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     2025
     2026    assertEqualsAnsiString('testAnsiTrimChars_LeftOnly', 'ay', tmpResult);
     2027  END;
     2028
     2029
     2030  PROCEDURE testAnsiTrimChars_RightOnly;
     2031  VAR
     2032    tmpResult : AnsiString;
     2033    tmpValue : AnsiString;
     2034  BEGIN
     2035    tmpValue := 'aybxbxx';
     2036    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     2037
     2038    assertEqualsAnsiString('testAnsiTrimChars_LeftOnly', 'ay', tmpResult);
     2039  END;
     2040
     2041
     2042  PROCEDURE testAnsiTrimChars_CharsInside;
     2043  VAR
     2044    tmpResult : AnsiString;
     2045    tmpValue : AnsiString;
     2046  BEGIN
     2047    tmpValue := 'bxabxvvx';
     2048    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     2049
     2050    assertEqualsAnsiString('testAnsiTrimChars_CharsInside', 'abxvv', tmpResult);
     2051  END;
     2052
     2053
     2054  PROCEDURE testAnsiTrimChars_Nothing;
     2055  VAR
     2056    tmpResult : AnsiString;
     2057    tmpValue : AnsiString;
     2058  BEGIN
     2059    tmpValue := 'acdef';
     2060    tmpResult := AnsiStrTrimChars(tmpValue, ['b', 'x']);
     2061
     2062    assertEqualsAnsiString('testAnsiTrimChars_Nothing', 'acdef', tmpResult);
     2063  END;
     2064
     2065
     2066  PROCEDURE testAnsiTrimChars_ReallyLong;
     2067  VAR
     2068    tmpResult : AnsiString;
     2069    tmpValue : AnsiString;
     2070  BEGIN
     2071    tmpValue := '0123456789';
     2072    tmpValue := tmpValue + tmpValue;
     2073    tmpValue := tmpValue + tmpValue;
     2074    tmpValue := tmpValue + tmpValue;
     2075    tmpValue := tmpValue + tmpValue;
     2076    tmpValue := tmpValue + tmpValue;
     2077    assertEqualsInt('testAnsiTrimChars_ReallyLong', 320, Length(tmpValue));
     2078
     2079    tmpResult := AnsiStrTrimChars(tmpValue, ['8', '9', '0', '1']);
     2080
     2081    assertEqualsInt('testAnsiTrimChars_ReallyLong', 316, Length(tmpResult));
     2082  END;
     2083
     2084
     2085  // -------------------------------------------------------------------
     2086
     2087
     2088  PROCEDURE testAnsiTrim;
     2089  VAR
     2090    tmpResult : String;
     2091    tmpValue : AnsiString;
     2092  BEGIN
     2093    tmpValue := '  a bc ';
     2094    tmpResult := AnsiStrTrim(tmpValue);
     2095
     2096    assertEqualsAnsiString('testAnsiTrim', 'a bc', tmpResult);
     2097  END;
     2098
     2099
     2100  PROCEDURE testAnsiTrim_ReallyLong;
     2101  VAR
     2102    tmpResult : AnsiString;
     2103    tmpValue : AnsiString;
     2104  BEGIN
     2105    tmpValue := '0123456789';
     2106    tmpValue := tmpValue + tmpValue;
     2107    tmpValue := tmpValue + tmpValue;
     2108    tmpValue := tmpValue + tmpValue;
     2109    tmpValue := tmpValue + tmpValue;
     2110    tmpValue := tmpValue + tmpValue;
     2111    tmpValue := '  ' + tmpValue + '    ';
     2112    assertEqualsInt('testAnsiTrim_ReallyLong', 326, Length(tmpValue));
     2113
     2114    tmpResult := AnsiStrTrim(tmpValue);
     2115
     2116    assertEqualsInt('testAnsiTrim_ReallyLong', 320, Length(tmpResult));
     2117  END;
     2118
     2119
     2120  // -------------------------------------------------------------------
    16772121
    16782122
    … …  
    18362280    result.add(@testStrExtractStringsQuoted_ManyParts);
    18372281
     2282    result.add(@testCaseInsensitivePos_Empty);
     2283    result.add(@testCaseInsensitivePos_EmptyPart);
     2284    result.add(@testCaseInsensitivePos_EmptyString);
     2285    result.add(@testCaseInsensitivePos_PartLarger);
     2286    result.add(@testCaseInsensitivePos_AtLeft);
     2287    result.add(@testCaseInsensitivePos_Middle);
     2288    result.add(@testCaseInsensitivePos_AtRight);
     2289    result.add(@testCaseInsensitivePos);
     2290
     2291  // --------------------
     2292  // ---- AnsiString ----
     2293  // --------------------
     2294
     2295
     2296    result.add(@testAnsiTrimLeftChars_Empty);
     2297    result.add(@testAnsiTrimLeftChars_RemoveAll);
     2298    result.add(@testAnsiTrimLeftChars_OneLeft);
     2299    result.add(@testAnsiTrimLeftChars_LeftOnly);
     2300    result.add(@testAnsiTrimLeftChars_CharsInside);
     2301    result.add(@testAnsiTrimLeftChars_Nothing);
     2302    result.add(@testAnsiTrimLeftChars_ReallyLong);
     2303
     2304    result.add(@testAnsiTrimRightChars_Empty);
     2305    result.add(@testAnsiTrimRightChars_RemoveAll);
     2306    result.add(@testAnsiTrimRightChars_OneLeft);
     2307    result.add(@testAnsiTrimRightChars_RightOnly);
     2308    result.add(@testAnsiTrimRightChars_CharsInside);
     2309    result.add(@testAnsiTrimRightChars_Nothing);
     2310    result.add(@testAnsiTrimRightChars_ReallyLong);
     2311
     2312    result.add(@testAnsiTrimChars_Empty);
     2313    result.add(@testAnsiTrimChars_RemoveAll);
     2314    result.add(@testAnsiTrimChars_OneLeftFromLeft);
     2315    result.add(@testAnsiTrimChars_OneLeftFromRight);
     2316    result.add(@testAnsiTrimChars_LeftOnly);
     2317    result.add(@testAnsiTrimChars_RightOnly);
     2318    result.add(@testAnsiTrimChars_CharsInside);
     2319    result.add(@testAnsiTrimChars_Nothing);
     2320    result.add(@testAnsiTrimChars_ReallyLong);
     2321
     2322    result.add(@testAnsiTrim);
     2323    result.add(@testAnsiTrim_ReallyLong);
     2324
     2325
    18382326  END;
    18392327

  • trunk/NewView/unittests/testassert.pas

    r68 r110  
    99
    1010  PROCEDURE assertEqualsString(aTestDescription : String; anExpectedValue : String; aRealValue : String);
     11  PROCEDURE assertEqualsAnsiString(aTestDescription : String; anExpectedValue : AnsiString; aRealValue : AnsiString);
    1112  PROCEDURE assertEqualsInt(aTestDescription : String; anExpectedValue : INTEGER; aRealValue : INTEGER);
    1213  PROCEDURE assertEqualsLongWord(aTestDescription : String; anExpectedValue : LongWord; aRealValue : LongWord);
    … …  
    1920  PROCEDURE assertEqualsString(aTestDescription : String; anExpectedValue : String; aRealValue : String);
    2021  VAR
    21     tmpMessage : String;
     22    tmpMessage : AnsiString;
     23  BEGIN
     24    if (aRealValue <> anExpectedValue) then
     25    begin
     26      tmpMessage := 'Failed: ' + aTestDescription + ' Expected: ''';
     27      tmpMessage := tmpMessage + anExpectedValue;
     28      tmpMessage := tmpMessage + ''' but it was: ''';
     29      tmpMessage := tmpMessage + aRealValue;
     30      tmpMessage := tmpMessage + '''';
     31      raise EAssertFailed.Create(tmpMessage);
     32    end;
     33  END;
     34
     35
     36  PROCEDURE assertEqualsAnsiString(aTestDescription : String; anExpectedValue : AnsiString; aRealValue : AnsiString);
     37  VAR
     38    tmpMessage : AnsiString;
    2239  BEGIN
    2340    if (aRealValue <> anExpectedValue) then
Note: See TracChangeset for help on using the changeset viewer.