unit testStringUnit;

interface

uses
  StringUnit,
  ConstUnit,
  XPtest,
end_uses;


procedure testByteType;
procedure testCharToByteLen;
procedure testStringTextPartsCompare;
procedure testRangeAnsiPosForwardBackward;
procedure testRangeWidePosForwardBackward;

procedure testCopyIndex;

procedure testMapStringW;
procedure testConvertKataKana;
procedure testConvertNumeric;
procedure testConvertSymbol;
procedure testConvertAlphabet;
procedure testCheckStrInTable;
procedure testCheckWideCharInTable;
procedure testChangeLineBreakes;
procedure testStringsReplace;
procedure testWideStringsReplace;
procedure testEncodeEscapeSequence;
procedure testDecodeEscapeSequence;
procedure testWideStringsWordReplace;

procedure testTrimLeftChar;
procedure testTrimRightChar;
procedure testTrimChar;

procedure testOneTrimChar;
procedure testGetTagText;
procedure testInStr;
procedure testWideCharByteLength;
procedure testCharIndexToByteIndex;
procedure testByteIndexToCharIndex;
procedure testCharLengthToByteLength;
procedure testIncludeBothEndsStr;
procedure testExcludeBothEndsStr;


implementation


    procedure testByteType;
    begin
      Check(True, IsDBCSLeadChar( ('る'[1])  ));
      Check(True, IsDBCSLeadChar( ('る'[2])  ));

      Check(True, IsDBCSLeadChar( ('あ'[1])  ));
      Check(False, IsDBCSLeadChar( ('あ'[2])  ));

      //↓SysUtilで使われているWinAPI関数
      //Check(True, IsDBCSLeadByte( Byte('る'[1])  ));
      //Check(True, IsDBCSLeadByte( Byte('る'[2])  ));
      //Check(True, IsDBCSLeadByte( Byte('あ'[1])  ));
      //Check(False, IsDBCSLeadByte( Byte('あ'[2])  ));

      Check(mbSingleByte, ByteType('ABC', 1));
      Check(mbLeadByte, ByteType('あ', 1));
      Check(mbTrailByte, ByteType('あ', 2));
      Check(mbLeadByte, ByteType('る', 1));
      Check(mbTrailByte, ByteType('る', 2));
      Check(mbLeadByte, ByteType('ああああ', 1));
      Check(mbTrailByte, ByteType('ああああ', 2));
      Check(mbLeadByte, ByteType('ああああ', 3));
      Check(mbTrailByte, ByteType('ああああ', 4));
      Check(mbLeadByte, ByteType('ああああ', 5));
      Check(mbTrailByte, ByteType('ああああ', 6));
      Check(mbLeadByte, ByteType('ああああ', 7));
      Check(mbTrailByte, ByteType('ああああ', 8));
      Check(mbLeadByte, ByteType('るるるる', 1));
      Check(mbTrailByte, ByteType('るるるる', 2));
      Check(mbLeadByte, ByteType('るるるる', 3));
      Check(mbTrailByte, ByteType('るるるる', 4));
      Check(mbLeadByte, ByteType('るるるる', 5));
      Check(mbTrailByte, ByteType('るるるる', 6));
      Check(mbLeadByte, ByteType('るるるる', 7));
      Check(mbTrailByte, ByteType('るるるる', 8));

      Check(mbLeadByte, ByteType('ABCああああ', 4));
      Check(mbTrailByte, ByteType('ABCああああ', 5));
      Check(mbLeadByte, ByteType('ABCああああ', 6));
      Check(mbTrailByte, ByteType('ABCああああ', 7));
      Check(mbLeadByte, ByteType('ABCああああ', 8));
      Check(mbTrailByte, ByteType('ABCああああ', 9));
      Check(mbLeadByte, ByteType('ABCああああ', 10));
      Check(mbTrailByte, ByteType('ABCああああ', 11));
      Check(mbLeadByte, ByteType('ABCるるるる', 4));
      Check(mbTrailByte, ByteType('ABCるるるる', 5));
      Check(mbLeadByte, ByteType('ABCるるるる', 6));
      Check(mbTrailByte, ByteType('ABCるるるる', 7));
      Check(mbLeadByte, ByteType('ABCるるるる', 8));
      Check(mbTrailByte, ByteType('ABCるるるる', 9));
      Check(mbLeadByte, ByteType('ABCるるるる', 10));
      Check(mbTrailByte, ByteType('ABCるるるる', 11));
    end;
    procedure testCharToByteLen;
    begin
      Check( 2, CharToByteLen('あいうえお', 1));
      Check( 6, CharToByteLen('あいうえお', 3));
      Check(10, CharToByteLen('あいうえお', 5));
      Check(10, CharToByteLen('あいうえお', 6));
      Check( 1, CharToByteLen('ABC123あいうえお', 1));
      Check( 6, CharToByteLen('ABC123あいうえお', 6));
      Check( 8, CharToByteLen('ABC123あいうえお', 7));
      Check(16, CharToByteLen('ABC123あいうえお',11));
    end;
procedure testStringTextPartsCompare;

    procedure CheckFunctionAnsi(ReturnStrValue, ReturnTextValue: Boolean;
     const Sub, S: String; StrIndex: Integer);
    begin
      Check( ReturnStrValue, AnsiStringPartsCompare(Sub, S, StrIndex) );
      Check( ReturnTextValue, AnsiTextPartsCompare(Sub, S, StrIndex) );
    end;

    procedure CheckFunctionWide(ReturnStrValue, ReturnTextValue: Boolean;
     const Sub, S: WideString; StrIndex: Integer);
    begin
      Check( ReturnStrValue, WideStringPartsCompare(Sub, S, StrIndex) );
      Check( ReturnTextValue, WideTextPartsCompare(Sub, S, StrIndex) );
    end;

    procedure CheckFunction(ReturnStrValue, ReturnTextValue: Boolean;
     const Sub, S: WideString; AnsiStrIndex, WideStrIndex: Integer);
    begin
      CheckFunctionAnsi(ReturnStrValue, ReturnTextValue, Sub, S, AnsiStrIndex);
      CheckFunctionWide(ReturnStrValue, ReturnTextValue, Sub, S, WideStrIndex);
    end;

begin
  CheckFunction( True, True, 'あ', 'あいうえお',    1,  1);
  CheckFunction( True, True, 'うえ', 'あいうえお',  5,  3);
  CheckFunction( True, True, 'お', 'あいうえお',    9,  5);

  CheckFunction(False,False, 'あ', 'あいうえお',    0,  0);
  CheckFunction(False,False, 'あ', 'あいうえお',    2,  2);
  CheckFunction(False,False, 'うえ', 'あいうえお',  4,  2);
  CheckFunction(False,False, 'うえ', 'あいうえお',  6,  4);
  CheckFunction(False,False, 'うえ', 'あいうえお',  8,  5);
  CheckFunction(False,False, 'お', 'あいうえお',    8,  4);
  CheckFunction(False,False, 'お', 'あいうえお',   11,  6);

  CheckFunction( True, True, 'D', 'ABCDEF', 4,  4);
  CheckFunction(False, True, 'D', 'abcdef', 4,  4);

  CheckFunction( True, True, 'Ｄ', 'ＡＢＣＤＥＦ', 7,   4);
  CheckFunction(False, True, 'Ｄ', 'ａｂｃｄｅｆ', 7,   4);

  CheckFunction(False,False, 'ABC', 'AB', 1,    1);

//  CheckFunction(False, False, 'ｰ', '久々', 3, 2);
    CheckFunctionAnsi(False, False, 'ｰ', '久々', 3);
    CheckFunctionWide(True, True, 'ｰ', '久々', 2);
    {↑？？これは何をテストしているのだろう？既存バグなのかな？}
end;
procedure testRangeAnsiPosForwardBackward;

    procedure CheckFunction(ForwardSearchIndex, BackwardSearchIndex: Integer;
     const SubStr, S: String; RangeStart, RangeCount: Integer);
    begin
      Check( ForwardSearchIndex, RangeAnsiPosForward(SubStr, S, RangeStart, RangeCount));
      Check( BackwardSearchIndex, RangeAnsiPosBackward(SubStr, S, RangeStart, RangeCount));
    end;

begin
  CheckFunction( 0, 0, 'ABC', 'abcdefghi', 1, 3);
  CheckFunction( 1, 1, 'ABC', 'ABCDEFGHI', 1, 3);
  CheckFunction( 0, 0, 'ABC', 'ABCDEFGHI', 1, 2);
  CheckFunction( 1, 1, 'ABC', 'ABCDEFGHI', 1, 4);
  CheckFunction( 0, 0, 'ABC', 'ABCDEFGHI', 2, 4);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 1, 6);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 1, 5);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 3, 6);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 4, 3);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 4, 2);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 5, 5);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 0, 6);

  CheckFunction( 1, 1, 'ABC', 'ABCDEFGHI', 1, MaxInt);
  Check( 1, RangeAnsiPosForward('ABC', 'ABCDEFGHI', 1) );
  Check( 1, RangeAnsiPosForward('ABC', 'ABCDEFGHI') );
  Check( 1, RangeAnsiPosBackward('ABC', 'ABCDEFGHI', 1) );
  Check( 1, RangeAnsiPosBackward('ABC', 'ABCDEFGHI') );

  CheckFunction( 0, 0, 'ABC', 'ABCDEFGHI', 2, MaxInt);
  Check( 0, RangeAnsiPosForward('ABC', 'ABCDEFGHI', 2) );
  Check( 0, RangeAnsiPosBackward('ABC', 'ABCDEFGHI', 2) );

  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 1, MaxInt);
  Check( 4, RangeAnsiPosForward('DEF', 'ABCDEFGHI') );
  Check( 4, RangeAnsiPosBackward('DEF', 'ABCDEFGHI') );

  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 3, MaxInt);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 4, MaxInt);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 5, MaxInt);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 0, MaxInt);
//
  CheckFunction( 1, 1, 'あいう', 'あいう１２３GHI', 1, 6);
  CheckFunction( 0, 0, 'あいう', 'あいう１２３GHI', 1, 5);
  CheckFunction( 1, 1, 'あいう', 'あいう１２３GHI', 1, 7);
  CheckFunction( 0, 0, 'あいう', 'あいう１２３GHI', 2, 6);
  CheckFunction( 7, 7, '１２３', 'あいう１２３GHI', 1, 12);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 1, 11);
  CheckFunction( 7, 7, '１２３', 'あいう１２３GHI', 7, 12);
  CheckFunction( 7, 7, '１２３', 'あいう１２３GHI', 7, 6);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 7, 5);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 8, 8);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 0, 12);

  CheckFunction( 1, 1, 'あいう', 'あいう１２３GHI', 1, MaxInt);
  Check( 1, RangeAnsiPosForward('あいう', 'あいう１２３GHI', 1) );
  Check( 1, RangeAnsiPosForward('あいう', 'あいう１２３GHI') );
  Check( 1, RangeAnsiPosBackward('あいう', 'あいう１２３GHI', 1) );
  Check( 1, RangeAnsiPosBackward('あいう', 'あいう１２３GHI') );

  CheckFunction( 0, 0, 'あいう', 'あいう１２３GHI', 2, MaxInt);
  Check( 0, RangeAnsiPosForward('あいう', 'あいう１２３GHI', 2) );
  Check( 0, RangeAnsiPosBackward('あいう', 'あいう１２３GHI', 2) );

  CheckFunction( 7, 7, '１２３', 'あいう１２３GHI', 1, MaxInt);
  Check( 7, RangeAnsiPosForward('１２３', 'あいう１２３GHI') );
  Check( 7, RangeAnsiPosBackward('１２３', 'あいう１２３GHI') );

  CheckFunction( 7, 7, '１２３', 'あいう１２３GHI', 6, MaxInt);
  CheckFunction( 7, 7, '１２３', 'あいう１２３GHI', 7, MaxInt);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 8, MaxInt);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 0, MaxInt);
//

  CheckFunction( 1, 1, 'ABC', 'ABCDEFABCDEF', 1, 3);
  CheckFunction( 1, 7, 'ABC', 'ABCDEFABCDEF', 1, MaxInt);
  CheckFunction( 1, 7, 'ABC', 'ABCDEFABCDEF', 1, 9);
  CheckFunction( 1, 1, 'ABC', 'ABCDEFABCDEF', 1, 8);
  CheckFunction( 7, 7, 'ABC', 'ABCDEFABCDEF', 2, 8);
  CheckFunction( 0, 0, 'ABC', 'ABCDEFABCDEF', 2, 7);

  CheckFunction( 1, 1, 'あいう', 'あいう１２３あいう１２３', 1, 6);
  CheckFunction( 1,13, 'あいう', 'あいう１２３あいう１２３', 1, MaxInt);
  CheckFunction( 1,13, 'あいう', 'あいう１２３あいう１２３', 1, 18);
  CheckFunction( 1, 1, 'あいう', 'あいう１２３あいう１２３', 1, 17);
  CheckFunction(13,13, 'あいう', 'あいう１２３あいう１２３', 2, 17);
  CheckFunction( 0, 0, 'あいう', 'あいう１２３あいう１２３', 2, 16);
end;
procedure testRangeWidePosForwardBackward;

    procedure CheckFunction(ForwardSearchIndex, BackwardSearchIndex: Integer;
     const SubStr, S: WideString; RangeStart, RangeCount: Integer);
    begin
      Check( ForwardSearchIndex, RangeWidePosForward(SubStr, S, RangeStart, RangeCount));
      Check( BackwardSearchIndex, RangeWidePosBackward(SubStr, S, RangeStart, RangeCount));
    end;

begin
  CheckFunction( 1, 1, 'ABC', 'ABCDEFGHI', 1, 3);
  CheckFunction( 0, 0, 'ABC', 'ABCDEFGHI', 1, 2);
  CheckFunction( 1, 1, 'ABC', 'ABCDEFGHI', 1, 4);
  CheckFunction( 0, 0, 'ABC', 'ABCDEFGHI', 2, 4);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 1, 6);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 1, 5);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 3, 6);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 4, 3);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 4, 2);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 5, 5);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 0, 6);

  CheckFunction( 1, 1, 'ABC', 'ABCDEFGHI', 1, MaxInt);
  Check( 1, RangeWidePosForward('ABC', 'ABCDEFGHI', 1) );
  Check( 1, RangeWidePosForward('ABC', 'ABCDEFGHI') );
  Check( 1, RangeWidePosBackward('ABC', 'ABCDEFGHI', 1) );
  Check( 1, RangeWidePosBackward('ABC', 'ABCDEFGHI') );

  CheckFunction( 0, 0, 'ABC', 'ABCDEFGHI', 2, MaxInt);
  Check( 0, RangeWidePosForward('ABC', 'ABCDEFGHI', 2) );
  Check( 0, RangeWidePosBackward('ABC', 'ABCDEFGHI', 2) );

  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 1, MaxInt);
  Check( 4, RangeWidePosForward('DEF', 'ABCDEFGHI') );
  Check( 4, RangeWidePosBackward('DEF', 'ABCDEFGHI') );

  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 3, MaxInt);
  CheckFunction( 4, 4, 'DEF', 'ABCDEFGHI', 4, MaxInt);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 5, MaxInt);
  CheckFunction( 0, 0, 'DEF', 'ABCDEFGHI', 0, MaxInt);
//
  CheckFunction( 1, 1, 'あいう', 'あいう１２３GHI', 1, 3);
  CheckFunction( 0, 0, 'あいう', 'あいう１２３GHI', 1, 2);
  CheckFunction( 1, 1, 'あいう', 'あいう１２３GHI', 1, 4);
  CheckFunction( 0, 0, 'あいう', 'あいう１２３GHI', 2, 3);
  CheckFunction( 4, 4, '１２３', 'あいう１２３GHI', 1, 6);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 1, 5);
  CheckFunction( 4, 4, '１２３', 'あいう１２３GHI', 4, 6);
  CheckFunction( 4, 4, '１２３', 'あいう１２３GHI', 4, 3);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 4, 2);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 5, 4);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 0, 6);

  CheckFunction( 1, 1, 'あいう', 'あいう１２３GHI', 1, MaxInt);
  Check( 1, RangeWidePosForward('あいう', 'あいう１２３GHI', 1) );
  Check( 1, RangeWidePosForward('あいう', 'あいう１２３GHI') );
  Check( 1, RangeWidePosBackward('あいう', 'あいう１２３GHI', 1) );
  Check( 1, RangeWidePosBackward('あいう', 'あいう１２３GHI') );

  CheckFunction( 0, 0, 'あいう', 'あいう１２３GHI', 2, MaxInt);
  Check( 0, RangeWidePosForward('あいう', 'あいう１２３GHI', 2) );
  Check( 0, RangeWidePosBackward('あいう', 'あいう１２３GHI', 2) );

  CheckFunction( 4, 4, '１２３', 'あいう１２３GHI', 1, MaxInt);
  Check( 4, RangeWidePosForward('１２３', 'あいう１２３GHI') );
  Check( 4, RangeWidePosBackward('１２３', 'あいう１２３GHI') );

  CheckFunction( 4, 4, '１２３', 'あいう１２３GHI', 3, MaxInt);
  CheckFunction( 4, 4, '１２３', 'あいう１２３GHI', 4, MaxInt);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 5, MaxInt);
  CheckFunction( 0, 0, '１２３', 'あいう１２３GHI', 0, MaxInt);
//

  CheckFunction( 1, 1, 'ABC', 'ABCDEFABCDEF', 1, 3);
  CheckFunction( 1, 7, 'ABC', 'ABCDEFABCDEF', 1, MaxInt);
  CheckFunction( 1, 7, 'ABC', 'ABCDEFABCDEF', 1, 9);
  CheckFunction( 1, 1, 'ABC', 'ABCDEFABCDEF', 1, 8);
  CheckFunction( 7, 7, 'ABC', 'ABCDEFABCDEF', 2, 8);
  CheckFunction( 0, 0, 'ABC', 'ABCDEFABCDEF', 2, 7);

  CheckFunction( 1, 1, 'あいう', 'あいう１２３あいう１２３', 1, 3);
  CheckFunction( 1, 7, 'あいう', 'あいう１２３あいう１２３', 1, MaxInt);
  CheckFunction( 1, 7, 'あいう', 'あいう１２３あいう１２３', 1, 9);
  CheckFunction( 1, 1, 'あいう', 'あいう１２３あいう１２３', 1, 8);
  CheckFunction( 7, 7, 'あいう', 'あいう１２３あいう１２３', 2, 8);
  CheckFunction( 0, 0, 'あいう', 'あいう１２３あいう１２３', 2, 7);

  CheckFunction( 4, 4, 'ﾟДﾟ', 'ミ,,ﾟДﾟ彡', 1, 7);
  CheckFunction( 4, 4, '゜Д゜', 'ミ,,ﾟДﾟ彡', 1, 7);
  {↑なぜこれが一致するんだ...orz...}
  CheckFunction(1,1, 'リンゴ', 'リンゴ', 1, 3);
  CheckFunction(0,0, 'ﾘﾝｺﾞ', 'リンゴ', 1, 3);   //これは一致しない
  CheckFunction(1,1, 'リ', 'リンコ', 1, 3);
  CheckFunction(0,0, 'ﾘ', 'リンコ', 1, 3);      //これもだめ
  CheckFunction(0,0, 'リ', 'ﾘﾝｺ', 1, 3);        //これもだめ
  CheckFunction(4,4, '゜', 'ﾘﾝｺﾟ', 1, 4);
  {↑↓なぜこれが...orz...}
  CheckFunction(4,4, 'ﾟ', 'ﾘﾝｺ゜', 1, 4);
end;

procedure testCopyIndex;
begin
  Check('', CopyIndex('abcdefg', -1, 0));
  Check('', CopyIndex('abcdefg', 0, -1));
  Check('', CopyIndex('abcdefg', -3, 0));
  Check('', CopyIndex('abcdefg', 0, -3));
  Check('', CopyIndex('abcdefg', -10, -1));
  Check('', CopyIndex('abcdefg', -1, -10));
  Check('', CopyIndex('abcdefg', -10, -2));
  Check('', CopyIndex('abcdefg', -2, -10));

  Check('abc', CopyIndex('abcdefg', 1, 3));
  Check('abc', CopyIndex('abcdefg', 0, 3));
  Check('abc', CopyIndex('abcdefg', -10, 3));

  Check('', CopyIndex('abcdefg', 3, 1));
  Check('', CopyIndex('abcdefg', 3, 0));
  Check('', CopyIndex('abcdefg', 3, -10));

  Check('def', CopyIndex('abcdefg', 4, 6));
  Check('', CopyIndex('abcdefg', 6, 4));

  Check('efg', CopyIndex('abcdefg', 5, 7));
  Check('efg', CopyIndex('abcdefg', 5, 8));
  Check('efg', CopyIndex('abcdefg', 5, 10));

  Check('', CopyIndex('abcdefg', 7, 5));
  Check('', CopyIndex('abcdefg', 8, 5));
  Check('', CopyIndex('abcdefg', 10, 5));

  Check('g', CopyIndex('abcdefg', 7, 7));
  Check('g', CopyIndex('abcdefg', 7, 8));
  Check('', CopyIndex('abcdefg', 8, 8));
  Check('', CopyIndex('abcdefg', 8, 9));
  Check('', CopyIndex('abcdefg', 8, 15));
  Check('', CopyIndex('abcdefg', 9, 8));
  Check('', CopyIndex('abcdefg', 15, 8));
  Check('', CopyIndex('abcdefg', 10, 15));
  Check('', CopyIndex('abcdefg', 15, 10));

end;


procedure testMapStringW;
begin
  Check('あああ', KataToHira('アあア'));
  Check('あかさたなはまやらわをん', KataToHira('アカサタナハマヤラワヲン'));
  Check('アアア', HiraToKata('あアあ'));
  Check('アカサタナハマヤラワヲン', HiraToKata('あかさたなはまやらわをん'));

  Check('ｱｱｱ', KataToHira('ｱｱｱ'));

  Check('abc', ZenkakuToHankaku('ａｂｃ'));
  Check('ｱｱｱ', ZenkakuToHankaku('アアア'));
  Check('ａｂｃ', HankakuToZenkaku('abc'));
  Check('アアア', HankakuToZenkaku('ｱｱｱ'));
end;


procedure testConvertKataKana;
begin
  Check(ConvertZenKataToHanKata('ガギグゲゴ'),'ｶﾞｷﾞｸﾞｹﾞｺﾞ');
  Check(ConvertZenKataToHanKata('ザジズゼゾ'),'ｻﾞｼﾞｽﾞｾﾞｿﾞ');
  Check(ConvertZenKataToHanKata('ダヂヅデド'),'ﾀﾞﾁﾞﾂﾞﾃﾞﾄﾞ');
  Check(ConvertZenKataToHanKata('バビブベボ'),'ﾊﾞﾋﾞﾌﾞﾍﾞﾎﾞ');
  Check(ConvertZenKataToHanKata('パピプペポ'),'ﾊﾟﾋﾟﾌﾟﾍﾟﾎﾟ');
  Check(ConvertZenKataToHanKata('アイウエオ'),'ｱｲｳｴｵ');
  Check(ConvertZenKataToHanKata('カキクケコ'),'ｶｷｸｹｺ');
  Check(ConvertZenKataToHanKata('サシスセソ'),'ｻｼｽｾｿ');
  Check(ConvertZenKataToHanKata('タチツテト'),'ﾀﾁﾂﾃﾄ');
  Check(ConvertZenKataToHanKata('ナニヌネノ'),'ﾅﾆﾇﾈﾉ');
  Check(ConvertZenKataToHanKata('ハヒフヘホ'),'ﾊﾋﾌﾍﾎ');
  Check(ConvertZenKataToHanKata('マミムメモ'),'ﾏﾐﾑﾒﾓ');
  Check(ConvertZenKataToHanKata('ヤユヨ'),    'ﾔﾕﾖ');
  Check(ConvertZenKataToHanKata('ラリルレロ'),'ﾗﾘﾙﾚﾛ');
  Check(ConvertZenKataToHanKata('ワヲン'),    'ﾜｦﾝ');
  Check(ConvertZenKataToHanKata('ァィゥェォ'),'ｧｨｩｪｫ');
  Check(ConvertZenKataToHanKata('ャュョ'),    'ｬｭｮ');
  Check(ConvertZenKataToHanKata('ッ゜ー・、。「」'),'ｯﾟｰ・、。「」');
  {↑『・、。「」』が変換できないのは仕様らしい
  Check(ConvertZenKataToHanKata('ッ゜ー・、。「」'),'ｯﾟｰ･､｡｢｣');
  }

  Check('ガギグゲゴ',ConvertHanKataToZenKata('ｶﾞｷﾞｸﾞｹﾞｺﾞ'));
  Check('ザジズゼゾ',ConvertHanKataToZenKata('ｻﾞｼﾞｽﾞｾﾞｿﾞ'));
  Check('ダヂヅデド',ConvertHanKataToZenKata('ﾀﾞﾁﾞﾂﾞﾃﾞﾄﾞ'));
  Check('バビブベボ',ConvertHanKataToZenKata('ﾊﾞﾋﾞﾌﾞﾍﾞﾎﾞ'));
  Check('パピプペポ',ConvertHanKataToZenKata('ﾊﾟﾋﾟﾌﾟﾍﾟﾎﾟ'));
  Check('アイウエオ',ConvertHanKataToZenKata('ｱｲｳｴｵ'));
  Check('カキクケコ',ConvertHanKataToZenKata('ｶｷｸｹｺ'));
  Check('サシスセソ',ConvertHanKataToZenKata('ｻｼｽｾｿ'));
  Check('タチツテト',ConvertHanKataToZenKata('ﾀﾁﾂﾃﾄ'));
  Check('ナニヌネノ',ConvertHanKataToZenKata('ﾅﾆﾇﾈﾉ'));
  Check('ハヒフヘホ',ConvertHanKataToZenKata('ﾊﾋﾌﾍﾎ'));
  Check('マミムメモ',ConvertHanKataToZenKata('ﾏﾐﾑﾒﾓ'));
  Check('ヤユヨ',    ConvertHanKataToZenKata('ﾔﾕﾖ'));
  Check('ラリルレロ',ConvertHanKataToZenKata('ﾗﾘﾙﾚﾛ'));
  Check('ワヲン',    ConvertHanKataToZenKata('ﾜｦﾝ'));
  Check('ァィゥェォ',ConvertHanKataToZenKata('ｧｨｩｪｫ'));
  Check('ャュョ',    ConvertHanKataToZenKata('ｬｭｮ'));
  Check('ッ゜ー・、。「」', ConvertHanKataToZenKata('ｯﾟｰ･､｡｢｣'));
end;
procedure testConvertNumeric;
begin
  Check(ConvertNumericZenToHan('１２３４５'),'12345');
  Check('１２３４５', ConvertNumericHanToZen('12345'));
end;
procedure testConvertSymbol;
begin
  Check(ConvertSymbolZenToHan('！？＄￥％＆＃'),'!?$\%&#');
  Check('！？＄￥％＆＃', ConvertSymbolHanToZen('!?$\%&#'));
end;
procedure testConvertAlphabet;
begin
  Check(ConvertAlphabetZenToHan('ＨＩＪＫＬＭＮ'),'HIJKLMN');
  Check('ＨＩＪＫＬＭＮ', ConvertAlphabetHanToZen('HIJKLMN'));
end;
procedure testStrCount1;
begin
  Check(0, StrCount('A', '') );
  Check(0, StrCount('ABC', '') );
  Check(0, StrCount('', 'A') );
  Check(0, StrCount('', 'ABC') );
  Check(1, StrCount('A', 'A') );
  Check(3, StrCount('A', 'AAA') );
  Check(1, StrCount('A', 'ABC') );
  Check(2, StrCount('A', 'ABCABC') );
  Check(3, StrCount('ABC', 'ABCABCABC') );
  Check(2, StrCount('BCA', 'ABCABCABC') );
  Check(1, StrCount('AA', 'AAA') );

  Check(0, StrCount('A', '', ifByte) );
  Check(0, StrCount('ABC', '', ifByte) );
  Check(0, StrCount('', 'A', ifByte) );
  Check(0, StrCount('', 'ABC', ifByte) );
  Check(1, StrCount('A', 'A', ifByte) );
  Check(3, StrCount('A', 'AAA', ifByte) );
  Check(1, StrCount('A', 'ABC', ifByte) );
  Check(2, StrCount('A', 'ABCABC', ifByte) );
  Check(3, StrCount('ABC', 'ABCABCABC', ifByte) );
  Check(2, StrCount('BCA', 'ABCABCABC', ifByte) );
  Check(2, StrCount('AA', 'AAA', ifByte) );

  Check(0, StrCount('Ａ', '') );
  Check(0, StrCount('ＡＢＣ', '') );
  Check(0, StrCount('', 'Ａ') );
  Check(0, StrCount('', 'ＡＢＣ') );
  Check(1, StrCount('Ａ', 'Ａ') );
  Check(3, StrCount('Ａ', 'ＡＡＡ') );
  Check(1, StrCount('Ａ', 'ＡＢＣ') );
  Check(2, StrCount('Ａ', 'ＡＢＣＡＢＣ') );
  Check(3, StrCount('ＡＢＣ', 'ＡＢＣＡＢＣＡＢＣ') );
  Check(2, StrCount('ＢＣＡ', 'ＡＢＣＡＢＣＡＢＣ') );
  Check(1, StrCount('ＡＡ', 'ＡＡＡ') );

  Check(0, StrCount('Ａ', '', ifByte) );
  Check(0, StrCount('ＡＢＣ', '', ifByte) );
  Check(0, StrCount('', 'Ａ', ifByte) );
  Check(0, StrCount('', 'ＡＢＣ', ifByte) );
  Check(1, StrCount('Ａ', 'Ａ', ifByte) );
  Check(3, StrCount('Ａ', 'ＡＡＡ', ifByte) );
  Check(1, StrCount('Ａ', 'ＡＢＣ', ifByte) );
  Check(2, StrCount('Ａ', 'ＡＢＣＡＢＣ', ifByte) );
  Check(3, StrCount('ＡＢＣ', 'ＡＢＣＡＢＣＡＢＣ', ifByte) );
  Check(2, StrCount('ＢＣＡ', 'ＡＢＣＡＢＣＡＢＣ', ifByte) );
  Check(2, StrCount('ＡＡ', 'ＡＡＡ', ifByte) );
end;
procedure testCheckStrInTable;
begin
  Check(itAllInclude, CheckStrInTable('123', '0123456789'));
  Check(itAllExclude, CheckStrInTable('ABC', '0123456789'));
  Check(itPartInclude, CheckStrInTable('ABC123', '0123456789'));
  Check(itUnknown, CheckStrInTable('', '0123456789'));
  Check(itUnknown, CheckStrInTable('123', ''));

  Check(itAllInclude, CheckStrInTable('123123321123', '123'));
  Check(itAllExclude, CheckStrInTable('ABCABCCBAABC', '123'));
  Check(itPartInclude, CheckStrInTable('ABC123', '123'));
end;
procedure testCheckWideCharInTable;
begin
  Check(True, CheckWideCharInTable('1', '0123456789'));
  Check(False, CheckWideCharInTable('A', '0123456789'));
  Check(False, CheckWideCharInTable('1', ''));
end;
procedure testInStr;
begin
  Check(True, InStr('A', 'ABC'));
  Check(True, InStr('B', 'ABC'));
  Check(True, InStr('C', 'ABC'));
  Check(True, InStr('あ', 'あいう'));
  Check(True, InStr('い', 'あいう'));
  Check(True, InStr('う', 'あいう'));
  Check(False, InStr('a', 'ABC'));
  Check(False, InStr('A', 'abc'));
  Check(False, InStr('え', 'あいう'));
end;
procedure testChangeLineBreakes;

    procedure CheckFunc(Source, CRLFResult, CRResult, LFResult: String);
    begin
      Check(CRLFResult, ChangeLineBreakes(Source, lbsCRLF));
      Check(CRResult  , ChangeLineBreakes(Source, lbsCR));
      Check(LFResult  , ChangeLineBreakes(Source, lbsLF));

      Check(CRResult  , ChangeLineBreakes(CRLFResult, lbsCR));
      Check(LFResult  , ChangeLineBreakes(CRLFResult, lbsLF));

      Check(CRLFResult, ChangeLineBreakes(CRResult  , lbsCRLF));
      Check(LFResult  , ChangeLineBreakes(CRResult  , lbsLF));

      Check(CRLFResult, ChangeLineBreakes(LFResult  , lbsCRLF));
      Check(CRResult  , ChangeLineBreakes(LFResult  , lbsCR));

    end;

//2009/01/07
//※lbsNoLineBreaksについては未テスト

begin
  //普通に変換
  CheckFunc(#10#13+'あいう'+#10#13+'えお'+#10#13,
            #13#10+'あいう'+#13#10+'えお'+#13#10,
            #13   +'あいう'+#13   +'えお'+#13,
            #10   +'あいう'+#10   +'えお'+#10);

  //混在
  CheckFunc(#13#10+'123'+#10#13+'ABC'+#13   +'あいう'+#10   ,
            #13#10+'123'+#13#10+'ABC'+#13#10+'あいう'+#13#10,
            #13   +'123'+#13   +'ABC'+#13   +'あいう'+#13   ,
            #10   +'123'+#10   +'ABC'+#10   +'あいう'+#10   );

  //連続
  CheckFunc(#10#13#10#13+'ABC'+#10#13#10#13+'あいう'+#10#13#10#13,
            #13#10#13#10+'ABC'+#13#10#13#10+'あいう'+#13#10#13#10,
            #13#13      +'ABC'+#13#13      +'あいう'+#13#13      ,
            #10#10      +'ABC'+#10#10      +'あいう'+#10#10      );

  //混在して連続
  CheckFunc(#10#13#13   +'123'+#13#13#10   +'ABC'+#10#10#13   ,
            #13#10#13#10+'123'+#13#10#13#10+'ABC'+#13#10#13#10,
            #13#13      +'123'+#13#13      +'ABC'+#13#13      ,
            #10#10      +'123'+#10#10      +'ABC'+#10#10      );

  CheckFunc(#10#13#13   +'123'+#13#10#13   +'あいう'+#10#13#10   ,
            #13#10#13#10+'123'+#13#10#13#10+'あいう'+#13#10#13#10,
            #13#13      +'123'+#13#13      +'あいう'+#13#13      ,
            #10#10      +'123'+#10#10      +'あいう'+#10#10      );

  //改行数のチェック
  CheckFunc(#10#13#10#13+
            'ABC'+#10#13#10#13#10#13+
            '123'+#10#13#10#13#10#13#10#13+
            'あいうえ'+#10#13#10#13#10#13#10#13#10#13,

            #13#10#13#10+
            'ABC'+#13#10#13#10#13#10+
            '123'+#13#10#13#10#13#10#13#10+
            'あいうえ'+#13#10#13#10#13#10#13#10#13#10,

            #13#13      +
            'ABC'+#13#13#13         +
            '123'+#13#13#13#13            +
            'あいうえ'+#13#13#13#13#13               ,

            #10#10      +
            'ABC'+#10#10#10         +
            '123'+#10#10#10#10            +
            'あいうえ'+#10#10#10#10#10               );
end;

procedure testStringsReplace;
var
  OldPatterns, NewPatterns: TStringDynArray;
begin
  SetLength(OldPatterns, 4);
  SetLength(NewPatterns, 4);

  OldPatterns[0] := '123';  NewPatterns[0] := 'ABC';
  OldPatterns[1] := 'ABC';  NewPatterns[1] := '123';
  OldPatterns[2] := '456';  NewPatterns[2] := 'DEF';
  OldPatterns[3] := 'DEF';  NewPatterns[3] := '456';

  Check('123ABC123ABC456DEF',
    StringsReplace('ABC123ABC123DEF456', OldPatterns, NewPatterns, False));

  Check('abcABCabcABCdefDEF',
    StringsReplace('abc123abc123def456', OldPatterns, NewPatterns, False));

  Check('123ABC123ABC456DEF',
    StringsReplace('abc123abc123def456', OldPatterns, NewPatterns, True));

  //オープン配列パラメータ指定
  Check('123ABC123ABC456DEF',
    StringsReplace('ABC123ABC123DEF456',
      ['123', 'ABC', '456', 'DEF'],
      ['ABC', '123', 'DEF', '456'], False));

end;

procedure testWideStringsReplace;
var
  OldPatterns, NewPatterns: TWideStringDynArray;
begin
  SetLength(OldPatterns, 4);
  SetLength(NewPatterns, 4);

  OldPatterns[0] := '123';  NewPatterns[0] := 'ABC';
  OldPatterns[1] := 'ABC';  NewPatterns[1] := '123';
  OldPatterns[2] := '456';  NewPatterns[2] := 'DEF';
  OldPatterns[3] := 'DEF';  NewPatterns[3] := '456';

  Check('123ABC123ABC456DEF',
    WideStringsReplace('ABC123ABC123DEF456', OldPatterns, NewPatterns, False));

  Check('abcABCabcABCdefDEF',
    WideStringsReplace('abc123abc123def456', OldPatterns, NewPatterns, False));


  Check('123ABC123ABC456DEF',
    WideStringsReplace('abc123abc123def456', OldPatterns, NewPatterns, True));

  //オープン配列パラメータ指定
  Check('123ABC123ABC456DEF',
    WideStringsReplace('ABC123ABC123DEF456',
      ['123', 'ABC', '456', 'DEF'],
      ['ABC', '123', 'DEF', '456'], False));



  SetLength(OldPatterns, 1);
  SetLength(NewPatterns, 1);

  OldPatterns[0] := '<BR>';  NewPatterns[0] := #13#10;

  Check(#13#10#13#10#13#10#13#10,
    WideStringsReplace('<BR><br><Br><bR>', OldPatterns, NewPatterns, True));

  SetLength(OldPatterns, 2);
  SetLength(NewPatterns, 2);
  OldPatterns[0] := 'A'; NewPatterns[0] := 'B';
  OldPatterns[1] := 'B'; NewPatterns[1] := 'A';
  Check('BA', WideStringsReplace('AB', OldPatterns, NewPatterns, True));


  SetLength(OldPatterns, 1);
  SetLength(NewPatterns, 1);

  OldPatterns[0] := 'function';  NewPatterns[0] := 'FUNCTION';

  Check(' FUNCTION ',
    WideStringsReplace(' function ', OldPatterns, NewPatterns, True));

end;

procedure testEncodeEscapeSequence;
begin
  Check('ABC\r\nDEF\r\n', EncodeEscapeSequence('ABC'#13#10'DEF'#13#10));
  Check('ABC\rDEF\n', EncodeEscapeSequence('ABC'#13'DEF'#10));
  Check('\rDEF\n', EncodeEscapeSequence(#13'DEF'#10));
  Check('\\rDEF\\n', EncodeEscapeSequence('\rDEF\n'));
  Check('\\\\rDEF\\\\n', EncodeEscapeSequence('\\rDEF\\n'));
  Check('ABC\r\nDEF\r\n', EncodeEscapeSequence('ABC'#13#10'DEF'#13#10));
end;

procedure testDecodeEscapeSequence;
begin
  Check('ABC'#13#10'DEF'#13#10, DecodeEscapeSequence('ABC\r\nDEF\r\n'));
  Check('ABC'#13'DEF'#10, DecodeEscapeSequence('ABC\rDEF\n'));
  Check(#13'DEF'#10, DecodeEscapeSequence('\rDEF\n'));
  Check(#13'DEF'#10, DecodeEscapeSequence('\RDEF\N'));
  Check('\rDEF\n', DecodeEscapeSequence('\\rDEF\\n'));
  Check('\\rDEF\\n', DecodeEscapeSequence('\\\\rDEF\\\\n'));
  Check('ABC'#13#10'DEF'#13#10, DecodeEscapeSequence('ABC\R\NDEF\R\N'));
end;

procedure testWideStringsWordReplace;
var
  OldPatterns, NewPatterns: TWideStringDynArray;
begin
  SetLength(OldPatterns, 1);
  SetLength(NewPatterns, 1);

  OldPatterns[0] := 'select';  NewPatterns[0] := 'SELECT';

  Check('SELECT',
    WideStringsWordReplace('seleCT', OldPatterns, NewPatterns, True));

  Check(' SELECT ',
    WideStringsWordReplace(' seleCT ', OldPatterns, NewPatterns, True));

  Check('SELECT1',
    WideStringsWordReplace('seleCT1', OldPatterns, NewPatterns, True));

  Check('_seleCT',
    WideStringsWordReplace('_seleCT', OldPatterns, NewPatterns, True));


  OldPatterns[0] := 'ttp://';  NewPatterns[0] := 'http://';

  Check('http:// ',
    WideStringsWordReplace('ttp:// ', OldPatterns, NewPatterns, True));

  Check(' http:// ',
    WideStringsWordReplace(' ttp:// ', OldPatterns, NewPatterns, True));

  Check(' http:// ',
    WideStringsWordReplace(' http:// ', OldPatterns, NewPatterns, True));

  Check('http://www',
    WideStringsWordReplace('ttp://www', OldPatterns, NewPatterns, True));

  Check(' http://www',
    WideStringsWordReplace(' ttp://www', OldPatterns, NewPatterns, True));

  Check(' http://www',
    WideStringsWordReplace(' http://www', OldPatterns, NewPatterns, True));

  SetLength(OldPatterns, 2);
  SetLength(NewPatterns, 2);

  OldPatterns[0] := '''';  NewPatterns[0] := '"';
  OldPatterns[1] := '"';  NewPatterns[1] := '''';

  Check('''"''',
    WideStringsWordReplace('"''"', OldPatterns, NewPatterns, True));

  Check('s"',
    WideStringsWordReplace('s''', OldPatterns, NewPatterns, True));
  Check('''s',
    WideStringsWordReplace('"s', OldPatterns, NewPatterns, True));

  Check('se"l"ect',
    WideStringsWordReplace('se''l''ect', OldPatterns, NewPatterns, True));
  Check('''se"l"ect''',
    WideStringsWordReplace('"se''l''ect"', OldPatterns, NewPatterns, True));
  Check('"se''l''ect"',
    WideStringsWordReplace('''se"l"ect''', OldPatterns, NewPatterns, True));

end;


procedure testTrimLeftChar;
begin
  Check('あ', TrimLeftChar('　　あ', '　'));
  Check('う', TrimLeftChar('　　　う', '　'));
  Check('か', TrimLeftChar('あいうえおああいいか', 'あいうえお'));
  Check('X', TrimLeftChar('　　YY　X', '　Y'));
  Check('789', TrimLeftChar('012346789', '6543210'));
  Check('ABCXYZ', TrimLeftChar('XXYYZZABCXYZ', 'XYZ'));
  Check('', TrimLeftChar('XXYYZZABCXYZ', 'XYZABC'));
  Check('AAA'#9, TrimLeftChar(#9'AAA'#9, #9));
  Check(#9, TrimLeftChar('AAA'#9, 'A'));
  Check(#9'AAA', TrimLeftChar(#13#10#9'AAA', #13#10));
  Check(#13#10, TrimLeftChar(#9'AAA'#13#10, #9'A'));
  Check('123', TrimLeftChar('123', ''));
end;

procedure testTrimRightChar;
begin
  Check('　　', TrimRightChar('　　あ', 'あ'));
  Check('あいうえお', TrimRightChar('あいうえおああいいか', 'かいあ'));
  Check('う', TrimRightChar('う　　　', '　'));
  Check('　　YY', TrimRightChar('　　YY　X', '　X'));
  Check('012', TrimRightChar('012346789', '346789'));
  Check('XXYYZZABC', TrimRightChar('XXYYZZABCXYZ', 'XYZ'));
  Check('', TrimRightChar('XXYYZZABCXYZ', 'XYZABC'));
  Check(#9'AAA', TrimRightChar(#9'AAA'#9, #9));
  Check(#9, TrimRightChar(#9'AAA', 'A'));
  Check(#9'AAA', TrimRightChar(#9'AAA'#13#10, #13#10));
  Check(#13#10, TrimRightChar(#13#10#9'AAA', #9'A'));
  Check('123', TrimRightChar('123', ''));
end;

procedure testTrimChar;
begin
  Check('ABC', TrimChar('123467829ABC5212694192', '0123456789'));
  Check('', TrimChar('123467829ABC5212694192', 'ABC0123456789'));
  Check('かきくけこ', TrimChar('あいうえああいいかきくけこおおえういあい', 'あいうえお'));
  Check('AAA', TrimChar(#9'AAA'#9, #9));
  Check(#9, TrimChar(#9'AAA', 'A'));
  Check(#9'AAA', TrimChar(#9'AAA'#13#10, #13#10));
  Check(#13#10, TrimChar(#9'AAA'#13#10, #9'A'));
  Check('123', TrimChar('123', ''));

  Check('ABC DEF', TrimChar('   ABC DEF'#13#10'  '#13#10, CtrlCharTbl+' '));
end;

procedure testOneTrimChar;
begin
  Check('ABC',  OneTrimChar('"ABC"', '"'));
  Check('"ABC', OneTrimChar('"ABC', '"'));
  Check('ABC"', OneTrimChar('ABC"', '"'));
  Check('"ABC"',OneTrimChar('"ABC"', ''));
  Check('ABC',  OneTrimChar('ABC', ''));
  Check('ABC',  OneTrimChar('ABC', '"'));
  Check('ABC',  OneTrimChar('1ABC1', '123'));
  Check('2ABC2',  OneTrimChar('12ABC21', '123'));
  Check('1ABC2',OneTrimChar('1ABC2', '123'));
  Check('',  OneTrimChar('', '"'));
end;

procedure testGetTagText;
begin
  Check('aaa', GetTagText('<', '>', '<aaa>'));
  Check('aaa', GetTagText('<', '>', 'abc<aaa>def'));
  Check('aaa', GetTagText('"', '"', '"aaa"'));
  Check('aaa', GetTagText('"', '"', 'abc"aaa"def'));
end;

type TWideCharByteLength = (wcblSingle, wcblMulti);

procedure testWideCharByteLength;
begin
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('a')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('g')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('z')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('A')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('G')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('Z')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('\')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('[')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString(']')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('^')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('`')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('_')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('~')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('{')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('|')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('}')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('｡')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('｢')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('｣')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('､')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('･')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｦ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｧ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｨ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｩ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｪ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｫ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｬ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｭ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｮ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｯ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｰ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｱ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｲ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｳ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｴ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｵ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｶ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｷ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｸ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｹ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｺ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｻ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｼ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｽ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｾ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ｿ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾀ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾁ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾂ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾃ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾄ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾅ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾆ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾇ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾈ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾉ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾊ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾋ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾌ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾍ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾎ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾏ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾐ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾑ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾒ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾓ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾔ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾕ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾖ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾗ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾘ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾙ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾚ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾛ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾜ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾝ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾞ')[1])));
  Check(wcblSingle, WideCharByteLength(WideChar(WideString('ﾟ')[1])));
  Check(wcblMulti, WideCharByteLength(WideChar(WideString('ａ')[1])));
  Check(wcblMulti, WideCharByteLength(WideChar(WideString('Ａ')[1])));
end;

procedure testCharIndexToByteIndex;
begin
  Check(1, CharIndexToByteIndex('a', 1));
  Check(2, CharIndexToByteIndex('a', 2));
  Check(0, CharIndexToByteIndex('a', 3));
  Check(2, CharIndexToByteIndex('abc', 2));
  Check(4, CharIndexToByteIndex('abc', 4));
  Check(1, CharIndexToByteIndex('あ', 1));
  Check(3, CharIndexToByteIndex('あ', 2));
  Check(0, CharIndexToByteIndex('あ', 3));
  Check(3, CharIndexToByteIndex('あいう', 2));
  Check(7, CharIndexToByteIndex('あいう', 4));
  Check(8, CharIndexToByteIndex('123１２３abcＡＢＣ', 6));
  Check(11, CharIndexToByteIndex('123１２３abcＡＢＣ', 8));
  Check(15, CharIndexToByteIndex('123１２３abcＡＢＣ', 11));
  Check(19, CharIndexToByteIndex('123１２３abcＡＢＣ', 13));
  Check( 0, CharIndexToByteIndex('123１２３abcＡＢＣ', 14));
end;

procedure testByteIndexToCharIndex;
begin
  Check(1, ByteIndexToCharIndex('a', 1));
  Check(0, ByteIndexToCharIndex('a', 2));
  Check(0, ByteIndexToCharIndex('a', 3));
  Check(2, ByteIndexToCharIndex('abc', 2));
  Check(0, ByteIndexToCharIndex('abc', 4));
  Check(1, ByteIndexToCharIndex('あ', 1));
  Check(1, ByteIndexToCharIndex('あ', 2));
  Check(0, ByteIndexToCharIndex('あ', 3));
  Check(1, ByteIndexToCharIndex('あいう', 2));
  Check(2, ByteIndexToCharIndex('あいう', 4));
  Check(5, ByteIndexToCharIndex('123１２３abcＡＢＣ', 6));
  Check(6, ByteIndexToCharIndex('123１２３abcＡＢＣ', 8));
  Check(8, ByteIndexToCharIndex('123１２３abcＡＢＣ', 11));
  Check(10, ByteIndexToCharIndex('123１２３abcＡＢＣ', 13));
  Check(11, ByteIndexToCharIndex('123１２３abcＡＢＣ', 15));
  Check(12, ByteIndexToCharIndex('123１２３abcＡＢＣ', 18));
  Check( 0, ByteIndexToCharIndex('123１２３abcＡＢＣ', 19));
end;

procedure testCharLengthToByteLength;
begin
  Check(1, ByteLength('a'));
  Check(1, ByteLength('A'));
  Check(2, ByteLength('ａ'));
  Check(2, ByteLength('Ａ'));
  Check(18, ByteLength('123１２３abcＡＢＣ'));
  Check(25, ByteLength('確認に使用したコード12345'));
end;

procedure testIncludeBothEndsStr;
begin
  Check('"テスト"', IncludeBothEndsStr('テスト', '"'));
  Check('"テスト"', IncludeBothEndsStr('"テスト', '"'));
  Check('"テスト"', IncludeBothEndsStr('テスト"', '"'));
  Check('"テスト"', IncludeBothEndsStr('"テスト"', '"'));
  Check('<B>テスト<B>', IncludeBothEndsStr('テスト', '<B>'));
  Check('<B>テスト<B>', IncludeBothEndsStr('<B>テスト', '<B>'));
  Check('<B>テスト<B>', IncludeBothEndsStr('テスト<B>', '<B>'));
  Check('<B>テスト<B>', IncludeBothEndsStr('<B>テスト<B>', '<B>'));
end;

procedure testExcludeBothEndsStr;
begin
  Check('テスト', ExcludeBothEndsStr('"テスト"', '"'));
  Check('テスト', ExcludeBothEndsStr('"テスト', '"'));
  Check('テスト', ExcludeBothEndsStr('テスト"', '"'));
  Check('テスト', ExcludeBothEndsStr('テスト', '"'));
  Check('テスト', ExcludeBothEndsStr('<B>テスト<B>', '<B>'));
  Check('テスト', ExcludeBothEndsStr('<B>テスト', '<B>'));
  Check('テスト', ExcludeBothEndsStr('テスト<B>', '<B>'));
  Check('テスト', ExcludeBothEndsStr('テスト', '<B>'));
end;

end.