/***********************************************************************
* fstring-test.cpp - FString unit tests                                *
*                                                                      *
* This file is part of the Final Cut widget toolkit                    *
*                                                                      *
* Copyright 2018 Markus Gans                                           *
*                                                                      *
* The Final Cut is free software; you can redistribute it and/or       *
* modify it under the terms of the GNU Lesser General Public License   *
* as published by the Free Software Foundation; either version 3 of    *
* the License, or (at your option) any later version.                  *
*                                                                      *
* The Final Cut is distributed in the hope that it will be useful,     *
* but WITHOUT ANY WARRANTY; without even the implied warranty of       *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
* GNU Lesser General Public License for more details.                  *
*                                                                      *
* You should have received a copy of the GNU Lesser General Public     *
* License along with this program.  If not, see                        *
* <http://www.gnu.org/licenses/>.                                      *
***********************************************************************/

#include <langinfo.h>
#include <unistd.h>
#define __STDC_LIMIT_MACROS
#include <stdint.h>

#include <clocale>
#include <iomanip>
#include <string>
#include <vector>

#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestFixture.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestRunner.h>

#include <final/final.h>

//----------------------------------------------------------------------
// class FStringTest
//----------------------------------------------------------------------

#pragma pack(push)
#pragma pack(1)

class FStringTest : public CPPUNIT_NS::TestFixture
{
  public:
    FStringTest()
      : s(0)
    { }

    void setUp();
    void tearDown();

  protected:
    void NoArgumentTest();
    void initLengthTest();
    void copyConstructorTest();
    void assignmentTest();
    void additionAssignmentTest();
    void additionTest();
    void caseTest();
    void equalTest();
    void notEqualTest();
    void lessEqualTest();
    void lessTest();
    void greaterEqualTest();
    void greaterTest();
    void streamInsertionTest();
    void streamExtractionTest();
    void subscriptOperatorTest();
    void iteratorTest();
    void functionCallOperatorTest();
    void formatTest();
    void convertToNumberTest();
    void convertFromNumberTest();
    void exceptionTest();
    void trimTest();
    void subStringTest();
    void insertTest();
    void replaceTest();
    void overwriteTest();
    void removeTest();
    void includesTest();
    void controlCodesTest();

  private:
    FString* s;

    // Adds code needed to register the test suite
    CPPUNIT_TEST_SUITE (FStringTest);

    // Add a methods to the test suite
    CPPUNIT_TEST (NoArgumentTest);
    CPPUNIT_TEST (initLengthTest);
    CPPUNIT_TEST (copyConstructorTest);
    CPPUNIT_TEST (assignmentTest);
    CPPUNIT_TEST (additionAssignmentTest);
    CPPUNIT_TEST (additionTest);
    CPPUNIT_TEST (caseTest);
    CPPUNIT_TEST (equalTest);
    CPPUNIT_TEST (notEqualTest);
    CPPUNIT_TEST (lessEqualTest);
    CPPUNIT_TEST (lessTest);
    CPPUNIT_TEST (greaterEqualTest);
    CPPUNIT_TEST (greaterTest);
    CPPUNIT_TEST (streamInsertionTest);
    CPPUNIT_TEST (streamExtractionTest);
    CPPUNIT_TEST (subscriptOperatorTest);
    CPPUNIT_TEST (iteratorTest);
    CPPUNIT_TEST (functionCallOperatorTest);
    CPPUNIT_TEST (formatTest);
    CPPUNIT_TEST (convertToNumberTest);
    CPPUNIT_TEST (convertFromNumberTest);
    CPPUNIT_TEST (exceptionTest);
    CPPUNIT_TEST (trimTest);
    CPPUNIT_TEST (subStringTest);
    CPPUNIT_TEST (insertTest);
    CPPUNIT_TEST (replaceTest);
    CPPUNIT_TEST (overwriteTest);
    CPPUNIT_TEST (removeTest);
    CPPUNIT_TEST (includesTest);
    CPPUNIT_TEST (controlCodesTest);

    // End of test suite definition
    CPPUNIT_TEST_SUITE_END();
};
#pragma pack(pop)

//----------------------------------------------------------------------
void FStringTest::setUp()
{
  std::setlocale(LC_CTYPE, "");
  s = new FString('c');
}

//----------------------------------------------------------------------
void FStringTest::tearDown()
{
  delete s;
}

//----------------------------------------------------------------------
void FStringTest::NoArgumentTest()
{
  FString empty;
  CPPUNIT_ASSERT ( empty.isNull() );
  CPPUNIT_ASSERT ( empty.isEmpty() );
  CPPUNIT_ASSERT ( empty.getLength() == 0 );
  CPPUNIT_ASSERT ( empty.getUTF8length() == 0 );
  CPPUNIT_ASSERT ( empty.wc_str() == 0 );
  CPPUNIT_ASSERT ( empty.c_str() == 0 );
  CPPUNIT_ASSERT_EQUAL ( empty.toString(), std::string() );
  CPPUNIT_ASSERT ( strlen(FString(99).c_str()) == 0 );
  CPPUNIT_ASSERT ( wcslen(FString(99).wc_str()) == 0 );
  CPPUNIT_ASSERT ( strlen(FString("").c_str()) == 0 );
  CPPUNIT_ASSERT ( wcslen(FString("").wc_str()) == 0 );

  char* cstr = empty.c_str();
  CPPUNIT_ASSERT ( cstr == 0 );
  wchar_t* wcstr = empty.wc_str();
  CPPUNIT_ASSERT ( wcstr == 0 );
  std::string str = empty.toString();
  CPPUNIT_ASSERT ( str.length() == 0 );
  CPPUNIT_ASSERT ( str.size() == 0 );
  CPPUNIT_ASSERT ( str.empty() );
  const FString fstr = str;
  CPPUNIT_ASSERT ( ! fstr.isNull() );
  CPPUNIT_ASSERT ( fstr.isEmpty() );

  cstr = 0;
  CPPUNIT_ASSERT ( empty == cstr );
  CPPUNIT_ASSERT ( FString(std::string()).isEmpty() );
  CPPUNIT_ASSERT ( FString(char(0)).isEmpty() );
  wcstr = 0;
  CPPUNIT_ASSERT ( empty == wcstr );
  CPPUNIT_ASSERT ( FString(std::wstring()).isEmpty() );
  CPPUNIT_ASSERT ( FString(wchar_t(0)).isEmpty() );

  CPPUNIT_ASSERT ( ! empty.includes('A') );
  CPPUNIT_ASSERT ( ! empty.includes(L'A') );
  CPPUNIT_ASSERT ( ! empty.includes("123") );
  CPPUNIT_ASSERT ( ! empty.includes(L"123") );
  CPPUNIT_ASSERT ( ! empty.includes(std::string("123")) );
  CPPUNIT_ASSERT ( ! empty.includes(std::wstring(L"123")) );
  CPPUNIT_ASSERT ( ! empty.includes(FString("123")) );

  std::ostringstream out;
  out << empty;
  CPPUNIT_ASSERT ( out.str() == "" );

  // Fill the empty string with "123"
  empty << "123";
  CPPUNIT_ASSERT_EQUAL ( empty, FString(L"123") );

  empty.clear();
  CPPUNIT_ASSERT ( empty.isNull() );
}

//----------------------------------------------------------------------
void FStringTest::initLengthTest()
{
  const FString s1(0);
  CPPUNIT_ASSERT ( s1.getLength() == 0 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  const int  x1 = 10;
  const uInt x2 = 10;
  const FString s2(x1);
  CPPUNIT_ASSERT ( s2.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s2.isNull() );
  CPPUNIT_ASSERT ( s2.isEmpty() );

  const FString s3(x2);
  CPPUNIT_ASSERT ( s3.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s3.isNull() );
  CPPUNIT_ASSERT ( s3.isEmpty() );

  const FString s4(0, L'-');
  CPPUNIT_ASSERT ( s4.getLength() == 0 );
  CPPUNIT_ASSERT ( s4.isNull() );
  CPPUNIT_ASSERT ( s4.isEmpty() );

  const FString s5(0, '-');
  CPPUNIT_ASSERT ( s5.getLength() == 0 );
  CPPUNIT_ASSERT ( s5.isNull() );
  CPPUNIT_ASSERT ( s5.isEmpty() );

  const FString s6(0, char(0));
  CPPUNIT_ASSERT ( s6.getLength() == 0 );
  CPPUNIT_ASSERT ( s6.isNull() );
  CPPUNIT_ASSERT ( s6.isEmpty() );

  const FString s7(x1, '-');
  CPPUNIT_ASSERT ( s7.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s7.isNull() );
  CPPUNIT_ASSERT ( ! s7.isEmpty() );

  const FString s8(x2, '-');
  CPPUNIT_ASSERT ( s8.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s8.isNull() );
  CPPUNIT_ASSERT ( ! s8.isEmpty() );

  const FString s9(x1, L'-');
  CPPUNIT_ASSERT ( s9.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s9.isNull() );
  CPPUNIT_ASSERT ( ! s9.isEmpty() );

  const FString s10(x2, L'-');
  CPPUNIT_ASSERT ( s10.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s10.isNull() );
  CPPUNIT_ASSERT ( ! s10.isEmpty() );

  const FString s11(x2, wchar_t(0));
  CPPUNIT_ASSERT ( s11.getLength() == 10 );
  CPPUNIT_ASSERT ( ! s11.isNull() );
  CPPUNIT_ASSERT ( s11.isEmpty() );
}

//----------------------------------------------------------------------
void FStringTest::copyConstructorTest()
{
  const FString s1("abc");
  const FString s2(s1);
  CPPUNIT_ASSERT ( s2 == L"abc" );
  CPPUNIT_ASSERT ( s2.getLength() == 3 );
}

//----------------------------------------------------------------------
void FStringTest::assignmentTest()
{
  FString s1;
  s1 = static_cast<FString>(0);
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1 = std::wstring();
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1 = std::string();
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1 = static_cast<wchar_t*>(0);
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1 = static_cast<char*>(0);
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1 = wchar_t(0);
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1 = char(0);
  CPPUNIT_ASSERT ( ! s1 );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );

  const FString s2("abc");
  s1 = s2;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"abc" );
  CPPUNIT_ASSERT ( s1.getLength() == 3 );

  const std::wstring s3(L"def");
  s1 = s3;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"def" );
  CPPUNIT_ASSERT ( s1.getLength() == 3 );

  const std::string s4("ghi");
  s1 = s4;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"ghi" );
  CPPUNIT_ASSERT ( s1.getLength() == 3 );

  const wchar_t s5[] = L"abc";
  s1 = s5;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"abc" );
  CPPUNIT_ASSERT ( s1.getLength() == 3 );

  const char s6[] = "def";
  s1 = s6;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"def" );
  CPPUNIT_ASSERT ( s1.getLength() == 3 );

  const wchar_t s7 = L'#';
  s1 = s7;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"#" );
  CPPUNIT_ASSERT ( s1.getLength() == 1 );

  const char s8 = '%';
  s1 = s8;
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"%" );
  CPPUNIT_ASSERT ( s1.getLength() == 1 );

  s1.setString("A character string");
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == "A character string" );

  s1.setString(L"A wide character string");
  // Set the identical content again.
  // Requires no string replacement (new string = string)
  s1.setString(L"A wide character string");
  CPPUNIT_ASSERT ( s1 );
  CPPUNIT_ASSERT ( s1 == L"A wide character string" );

  s1.setString("");
  CPPUNIT_ASSERT ( s1 );

  s1.setString(L"");
  CPPUNIT_ASSERT ( s1 );

  s1.setString("");
  CPPUNIT_ASSERT ( s1 == "" );

  s1.setString(L"");
  CPPUNIT_ASSERT ( s1 == L"" );

  s1.setString("");
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1.setString(L"");
  CPPUNIT_ASSERT ( s1.isEmpty() );

  s1.setString("");
  CPPUNIT_ASSERT ( ! s1.isNull() );

  s1.setString(L"");
  CPPUNIT_ASSERT ( ! s1.isNull() );

  const wchar_t* wc = 0;
  s1.setString(wc);
  CPPUNIT_ASSERT ( s1.isEmpty() );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( ! s1 );

  const char* c = 0;
  s1.setString(c);
  CPPUNIT_ASSERT ( s1.isEmpty() );
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( ! s1 );
}

//----------------------------------------------------------------------
void FStringTest::additionAssignmentTest()
{
  FString s1;
  s1 += FString("abc");
  CPPUNIT_ASSERT ( s1 == L"abc" );
  s1 += FString("def");
  CPPUNIT_ASSERT ( s1 == L"abcdef" );
  s1 += FString();
  CPPUNIT_ASSERT ( s1 == L"abcdef" );
  s1 += FString("");
  CPPUNIT_ASSERT ( s1 == L"abcdef" );

  s1.clear();
  CPPUNIT_ASSERT ( s1.isNull() );
  CPPUNIT_ASSERT ( s1.isEmpty() );
  s1 += std::wstring(L"abc");
  CPPUNIT_ASSERT ( s1 == L"abc" );
  s1 += std::wstring(L"def");
  CPPUNIT_ASSERT ( s1 == L"abcdef" );

  s1.clear();
  s1 += const_cast<wchar_t*>(L"abc");
  CPPUNIT_ASSERT ( s1 == L"abc" );
  s1 += const_cast<wchar_t*>(L"def");
  CPPUNIT_ASSERT ( s1 == L"abcdef" );

  s1.clear();
  s1 += std::string("abc");
  CPPUNIT_ASSERT ( s1 == L"abc" );
  s1 += std::string("def");
  CPPUNIT_ASSERT ( s1 == L"abcdef" );

  s1.clear();
  s1 += const_cast<char*>("abc");
  CPPUNIT_ASSERT ( s1 == L"abc" );
  s1 += const_cast<char*>("def");
  CPPUNIT_ASSERT ( s1 == L"abcdef" );

  s1.clear();
  s1 += wchar_t('a');
  CPPUNIT_ASSERT ( s1 == L"a" );
  s1 += wchar_t('b');
  CPPUNIT_ASSERT ( s1 == L"ab" );

  s1.clear();
  s1 += char('a');
  CPPUNIT_ASSERT ( s1 == L"a" );
  s1 += char('b');
  CPPUNIT_ASSERT ( s1 == L"ab" );
}

//----------------------------------------------------------------------
void FStringTest::additionTest()
{
  // FString member operator
  const FString s1("abc");
  CPPUNIT_ASSERT ( s1 + FString("def") == L"abcdef" );
  CPPUNIT_ASSERT ( s1 + std::wstring(L"def") == L"abcdef" );
  CPPUNIT_ASSERT ( s1 + const_cast<wchar_t*>(L"def") == L"abcdef" );
  CPPUNIT_ASSERT ( s1 + std::string("def") == L"abcdef" );
  CPPUNIT_ASSERT ( s1 + const_cast<char*>("def") == L"abcdef" );
  CPPUNIT_ASSERT ( s1 + wchar_t(L'd') == L"abcd" );
  CPPUNIT_ASSERT ( s1 + char('d') == L"abcd" );

  // FString non-member operator
  FString s2("abc");
  CPPUNIT_ASSERT ( s2 + FString("def") == L"abcdef" );
  CPPUNIT_ASSERT ( s2 + std::wstring(L"def") == L"abcdef" );
  CPPUNIT_ASSERT ( s2 + const_cast<wchar_t*>(L"def") == L"abcdef" );
  CPPUNIT_ASSERT ( s2 + std::string("def") == L"abcdef" );
  CPPUNIT_ASSERT ( s2 + const_cast<char*>("def") == L"abcdef" );
  CPPUNIT_ASSERT ( s2 + wchar_t(L'd') == L"abcd" );
  CPPUNIT_ASSERT ( s2 + char('d') == L"abcd" );

  const std::wstring& s3 = L"abc";
  CPPUNIT_ASSERT ( s3 + FString("def") == L"abcdef" );

  const wchar_t s4[] = L"abc";
  CPPUNIT_ASSERT ( s4 + FString("def") == L"abcdef" );

  const std::string& s5 = "abc";
  CPPUNIT_ASSERT ( s5 + FString("def") == L"abcdef" );

  const char s6[] = "abc";
  CPPUNIT_ASSERT ( s6 + FString("def") == L"abcdef" );

  const wchar_t c1 = L'a';
  CPPUNIT_ASSERT ( c1 + s3 == L"aabc" );
  CPPUNIT_ASSERT ( c1 + FString("def") == L"adef" );

  const char c2 = 'a';
  CPPUNIT_ASSERT ( c2 + s5 == "aabc" );
  CPPUNIT_ASSERT ( c2 + FString("def") == L"adef" );

}

//----------------------------------------------------------------------
void FStringTest::caseTest()
{
  const FString str1("abc");
  CPPUNIT_ASSERT ( str1.toUpper() == "ABC" );

  const FString str2("XYZ");
  CPPUNIT_ASSERT ( str2.toLower() == "xyz" );
}

//----------------------------------------------------------------------
void FStringTest::equalTest()
{
  // std::string -> FString -> std::string
  const std::string s1 = "string";
  FString fs = s1;
  const std::string s2 = fs.toString();
  CPPUNIT_ASSERT ( s1 == s2 );

  // std::wstring -> FString -> std::wstring
  const std::wstring ws1 = L"wide string";
  fs = ws1;
  std::wstring ws2 = fs.wc_str();
  CPPUNIT_ASSERT ( ws1 == ws2 );

  const FString one_char('a');
  const char ch = 'a';
  CPPUNIT_ASSERT ( one_char == ch );
  CPPUNIT_ASSERT ( ch == one_char.c_str()[0] );
  CPPUNIT_ASSERT ( one_char.getLength() == 1 );

  const wchar_t wch = L'a';
  CPPUNIT_ASSERT ( one_char == wch );
  CPPUNIT_ASSERT ( wch == one_char.wc_str()[0] );

  const FString str(L"abc");
  const FString str2(L"abc");
  CPPUNIT_ASSERT ( str == str2 );

  const char cstr[] = "abc";
  CPPUNIT_ASSERT ( str == cstr );
  CPPUNIT_ASSERT ( str.getLength() == 3 );
  CPPUNIT_ASSERT ( str.getUTF8length() == 3 );
  CPPUNIT_ASSERT ( strncmp(cstr, str.c_str(), 3) == 0 );

  const wchar_t wcstr[] = L"abc";
  CPPUNIT_ASSERT ( str == wcstr );
  CPPUNIT_ASSERT ( wcsncmp(wcstr, str.wc_str(), 3) == 0 );

  const std::string st = "abc";
  CPPUNIT_ASSERT ( str == st );

  const std::wstring wst = L"abc";
  CPPUNIT_ASSERT ( str == wst );

  const FString null_str1;
  const FString null_str2;
  CPPUNIT_ASSERT ( ! (str == null_str2) );
  CPPUNIT_ASSERT ( ! (null_str1 == str) );
  CPPUNIT_ASSERT ( null_str1 == null_str2 );

  CPPUNIT_ASSERT ( s->c_str()[0] == 'c');
  CPPUNIT_ASSERT ( s->getLength() == 1 );
}

//----------------------------------------------------------------------
void FStringTest::notEqualTest()
{
  const FString one_char('@');
  const char ch = '!';
  CPPUNIT_ASSERT ( one_char != ch );
  CPPUNIT_ASSERT ( ch != one_char.c_str()[0] );
  CPPUNIT_ASSERT ( one_char.getLength() == 1 );

  const wchar_t wch = L'_';
  CPPUNIT_ASSERT ( one_char != wch );
  CPPUNIT_ASSERT ( wch != one_char.wc_str()[0] );

  const FString s1 = L"ABC";  // latin letter
  const FString s2 = L"АВС";  // cyrillic letters
  CPPUNIT_ASSERT ( s1 != s2 );

  const char cstr[] = "abc";
  CPPUNIT_ASSERT ( s1 != cstr );
  CPPUNIT_ASSERT ( s1.getLength() == 3 );
  CPPUNIT_ASSERT ( strlen(s1.c_str()) == 3 );
  CPPUNIT_ASSERT ( s2.getLength() == 3 );
  CPPUNIT_ASSERT ( strlen(s2.c_str()) == 6 );
  CPPUNIT_ASSERT ( s1.getUTF8length() == 3 );
  CPPUNIT_ASSERT ( s2.getUTF8length() == 3 );
  CPPUNIT_ASSERT ( strncmp(cstr, s1.c_str(), 3) != 0 );

  const wchar_t wcstr[] = L"abc";
  CPPUNIT_ASSERT ( s1 != wcstr );
  CPPUNIT_ASSERT ( wcsncmp(wcstr, s1.wc_str(), 3) != 0 );

  const std::string st = "abc";
  CPPUNIT_ASSERT ( s1 != st );

  const std::wstring wst = L"abc";
  CPPUNIT_ASSERT ( s1 != wst );

  const FString null_str1;
  const FString null_str2;
  CPPUNIT_ASSERT ( s1 != null_str2 );
  CPPUNIT_ASSERT ( null_str1 != s1 );
  CPPUNIT_ASSERT ( ! (null_str1 != null_str2) );

  CPPUNIT_ASSERT ( s->c_str()[0] != 's');
}

//----------------------------------------------------------------------
void FStringTest::lessEqualTest()
{
  const FString one_char('x');
  const char ch = 'z';
  CPPUNIT_ASSERT ( one_char <= ch );

  const wchar_t wch = L'z';
  CPPUNIT_ASSERT ( one_char <= wch );

  const FString s1 = L"xyz";
  const FString s2 = L"xyz";
  const FString s3 = L"xzz";
  CPPUNIT_ASSERT ( s1 <= s2 && s1 == s2 );
  CPPUNIT_ASSERT ( s1 <= s3 && s1 != s3 );

  const char cstr1[] = "xyz";
  const char cstr2[] = "xzz";
  CPPUNIT_ASSERT ( s1 <= cstr1 && s1 == cstr1 );
  CPPUNIT_ASSERT ( s1 <= cstr2 && s1 != cstr2 );

  const wchar_t wcstr1[] = L"xyz";
  const wchar_t wcstr2[] = L"xzz";
  CPPUNIT_ASSERT ( s1 <= wcstr1 && s1 == wcstr1 );
  CPPUNIT_ASSERT ( s1 <= wcstr2 && s1 != wcstr2 );

  const std::string st1 = "xyz";
  const std::string st2 = "xzz";
  CPPUNIT_ASSERT ( s1 <= st1 && s1 == st1 );
  CPPUNIT_ASSERT ( s1 <= st2 && s1 != st2 );

  const std::wstring wst1 = L"xyz";
  const std::wstring wst2 = L"xzz";
  CPPUNIT_ASSERT ( s1 <= wst1 && s1 == wst1 );
  CPPUNIT_ASSERT ( s1 <= wst2 && s1 != wst2 );

  const FString null_str1;
  const FString null_str2;
  const FString empty("");
  CPPUNIT_ASSERT ( ! (s1 <= null_str2) );
  CPPUNIT_ASSERT ( null_str1 <= s2 );
  CPPUNIT_ASSERT ( null_str1 <= null_str2 );
  CPPUNIT_ASSERT ( ! (s1 <= empty) );
}

//----------------------------------------------------------------------
void FStringTest::lessTest()
{
  const FString one_char('x');
  const char ch = 'z';
  CPPUNIT_ASSERT ( one_char < ch );

  const wchar_t wch = L'z';
  CPPUNIT_ASSERT ( one_char < wch );

  const FString s1 = L"xyz";
  const FString s2 = L"xzz";
  CPPUNIT_ASSERT ( s1 < s2 );

  const char cstr[] = "xzz";
  CPPUNIT_ASSERT ( s1 < cstr );

  const wchar_t wcstr[] = L"xzz";
  CPPUNIT_ASSERT ( s1 < wcstr );

  const std::string st = "xzz";
  CPPUNIT_ASSERT ( s1 < st  );

  const std::wstring wst = L"xzz";
  CPPUNIT_ASSERT ( s1 < wst );

  const FString null_str1;
  const FString null_str2;
  CPPUNIT_ASSERT ( ! (s1 < null_str2) );
  CPPUNIT_ASSERT ( null_str1 < s2 );
  CPPUNIT_ASSERT ( ! (null_str1 < null_str2) );
}

//----------------------------------------------------------------------
void FStringTest::greaterEqualTest()
{
  const FString one_char('x');
  const char ch = 'x';
  CPPUNIT_ASSERT ( one_char >= ch );

  const wchar_t wch = L'x';
  CPPUNIT_ASSERT ( one_char >= wch );

  const FString s1 = L"xyz";
  const FString s2 = L"xyz";
  const FString s3 = L"xxz";
  CPPUNIT_ASSERT ( s1 >= s2 && s1 == s2 );
  CPPUNIT_ASSERT ( s1 >= s3 && s1 != s3 );

  const char cstr1[] = "xyz";
  const char cstr2[] = "xxz";
  CPPUNIT_ASSERT ( s1 >= cstr1 && s1 == cstr1 );
  CPPUNIT_ASSERT ( s1 >= cstr2 && s1 != cstr2 );

  const wchar_t wcstr1[] = L"xyz";
  const wchar_t wcstr2[] = L"xxz";
  CPPUNIT_ASSERT ( s1 >= wcstr1 && s1 == wcstr1 );
  CPPUNIT_ASSERT ( s1 >= wcstr2 && s1 != wcstr2 );

  const std::string st1 = "xyz";
  const std::string st2 = "xxz";
  CPPUNIT_ASSERT ( s1 >= st1 && s1 == st1 );
  CPPUNIT_ASSERT ( s1 >= st2 && s1 != st2 );

  const std::wstring wst1 = L"xyz";
  const std::wstring wst2 = L"xxz";
  CPPUNIT_ASSERT ( s1 >= wst1 && s1 == wst1 );
  CPPUNIT_ASSERT ( s1 >= wst2 && s1 != wst2 );

  const FString null_str1;
  const FString null_str2;
  const FString empty("");
  CPPUNIT_ASSERT ( s1 >= null_str2 );
  CPPUNIT_ASSERT ( ! (null_str1 >= s2) );
  CPPUNIT_ASSERT ( null_str1 >= null_str2 );
  CPPUNIT_ASSERT ( ! (s1 <= empty) );
}

//----------------------------------------------------------------------
void FStringTest::greaterTest()
{
  const FString one_char('x');
  const char ch = 'w';
  CPPUNIT_ASSERT ( one_char > ch );

  const wchar_t wch = L'w';
  CPPUNIT_ASSERT ( one_char > wch );

  const FString s1 = L"xyz";
  const FString s2 = L"xww";
  CPPUNIT_ASSERT ( s1 > s2 );

  const char cstr[] = "xww";
  CPPUNIT_ASSERT ( s1 > cstr );

  const wchar_t wcstr[] = L"xww";
  CPPUNIT_ASSERT ( s1 > wcstr );

  const std::string st = "xww";
  CPPUNIT_ASSERT ( s1 > st  );

  const std::wstring wst = L"xww";
  CPPUNIT_ASSERT ( s1 > wst );

  const FString null_str1;
  const FString null_str2;
  CPPUNIT_ASSERT ( s1 > null_str2 );
  CPPUNIT_ASSERT ( ! (null_str1 > s2) );
  CPPUNIT_ASSERT ( ! (null_str1 > null_str2) );
}

//----------------------------------------------------------------------
void FStringTest::streamInsertionTest()
{
  FString out;
  out << FString("ABC");
  CPPUNIT_ASSERT ( out == L"ABC" );

  out.clear();
  out << std::string("ABC");
  CPPUNIT_ASSERT ( out == L"ABC" );

  out.clear();
  out << std::wstring(L"ABC");
  CPPUNIT_ASSERT ( out == L"ABC" );

  out.clear();
  out << const_cast<wchar_t*>(L"ABC");
  CPPUNIT_ASSERT ( out == L"ABC" );

  out.clear();
  out << const_cast<char*>("ABC");
  CPPUNIT_ASSERT ( out == L"ABC" );

  out.clear();
  out << wchar_t(L'A');
  CPPUNIT_ASSERT ( out == L"A" );

  out.clear();
  out << char('A');
  CPPUNIT_ASSERT ( out == L"A" );

  out.clear();
  out << sInt16(INT_LEAST16_MAX);
  CPPUNIT_ASSERT ( out == L"32767" );

  out.clear();
  out << sInt16(INT_LEAST16_MIN);
  CPPUNIT_ASSERT ( out == L"-32768" );

  out.clear();
  out << uInt16(UINT_LEAST16_MAX);
  CPPUNIT_ASSERT ( out == L"65535" );

  out.clear();
  out << int(1234567);
  CPPUNIT_ASSERT ( out == L"1234567" );

  out.clear();
  out << int(-1234567);
  CPPUNIT_ASSERT ( out == L"-1234567" );

  out.clear();
  out << uInt(12345678);
  CPPUNIT_ASSERT ( out == L"12345678" );

  out.clear();
  out << long(-34721053343141);
  CPPUNIT_ASSERT ( out == L"-34721053343141" );

  out.clear();
  out << uLong(4670148723459);
  CPPUNIT_ASSERT ( out == L"4670148723459" );

  out.clear();
  out << float(3.14159);
  CPPUNIT_ASSERT ( out == L"3.14159" );

  out.clear();
  out << double(3.1415926535);
  CPPUNIT_ASSERT ( out == L"3.1415926535" );

  out.clear();
  out << lDouble(3.141592653589793238L);
  CPPUNIT_ASSERT ( out == L"3.14159265358979324" );

  out = "abc";
  std::ostringstream ostream;
  ostream << out;
  CPPUNIT_ASSERT ( ostream.str() == "abc" );

  std::wostringstream wostream;
  wostream << out;
  CPPUNIT_ASSERT ( wostream.str() == L"abc" );
}

//----------------------------------------------------------------------
void FStringTest::streamExtractionTest()
{
  FString in_1;
  FString("ABC") >> in_1;
  CPPUNIT_ASSERT ( in_1 == "ABC" );

  std::wstring in_2;
  FString("ABC") >> in_2;
  CPPUNIT_ASSERT ( in_2 == L"ABC" );

  std::string in_3;
  FString("ABC") >> in_3;
  CPPUNIT_ASSERT ( in_3 == "ABC" );

  wchar_t in_4;
  FString("A") >> in_4;
  CPPUNIT_ASSERT ( in_4 == L'A' );

  char in_5;
  FString("A") >> in_5;
  CPPUNIT_ASSERT ( in_5 == L'A' );

  sInt16 in_6;
  FString("-12345") >> in_6;
  CPPUNIT_ASSERT ( in_6 == -12345 );

  uInt16 in_7;
  FString("33333") >> in_7;
  CPPUNIT_ASSERT ( in_7 == 33333 );

  int in_8;
  FString("-12345678") >> in_8;
  CPPUNIT_ASSERT ( in_8 == -12345678 );

  uInt in_9;
  FString("99999999") >> in_9;
  CPPUNIT_ASSERT ( in_9 == 99999999 );

  long in_10;
  FString("-1234567890") >> in_10;
  CPPUNIT_ASSERT ( in_10 == -1234567890 );

  uLong in_11;
  FString("9999999999999") >> in_11;
  CPPUNIT_ASSERT ( in_11 == 9999999999999 );

  float in_12;
  FString("2.71828") >> in_12;
  CPPUNIT_ASSERT ( in_12 == 2.71828f );

  double in_13;
  FString("2.7182818284590452353") >> in_13;
  CPPUNIT_ASSERT ( in_13 == 2.7182818284590452353 );

  FString in;
  std::istringstream istream("abc");
  istream >> in;
  CPPUNIT_ASSERT ( in == "abc" );

  std::wistringstream wistream(L"abc");
  wistream >> in;
  CPPUNIT_ASSERT ( in == "abc" );
}

//----------------------------------------------------------------------
void FStringTest::subscriptOperatorTest()
{
  FString s(3);
  CPPUNIT_ASSERT ( s[0] == L'\0' );
  CPPUNIT_ASSERT ( s[1] == L'\0' );
  CPPUNIT_ASSERT ( s[2] == L'\0' );
  s[0] = L'A';
  s[1] = L'B';
  s[2] = L'C';
  CPPUNIT_ASSERT ( s[0] == L'A' );
  CPPUNIT_ASSERT ( s[1] == L'B' );
  CPPUNIT_ASSERT ( s[2] == L'C' );
  CPPUNIT_ASSERT ( s == L"ABC" );
}

//----------------------------------------------------------------------
void FStringTest::iteratorTest()
{
  const FString& str = "123456789";
  CPPUNIT_ASSERT ( str.front() == L'1' );
  CPPUNIT_ASSERT ( str.back() == L'9' );

  FString::iterator iter = str.begin();
  CPPUNIT_ASSERT ( (*iter) == L'1' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'2' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'3' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'4' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'5' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'6' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'7' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'8' );
  ++iter;
  CPPUNIT_ASSERT ( (*iter) == L'9' );
  ++iter;
  CPPUNIT_ASSERT ( iter == str.end() );
}

//----------------------------------------------------------------------
void FStringTest::functionCallOperatorTest()
{
  FString str = L"test";
  CPPUNIT_ASSERT_EQUAL ( str, str() );

  FString copy = str();
  copy << L"string";
  CPPUNIT_ASSERT ( str() == "test" );
  CPPUNIT_ASSERT ( copy  == "teststring" );
}

//----------------------------------------------------------------------
void FStringTest::formatTest()
{
  FString str1;
  int num = 3;
  char location[] = "zoo";
  str1.sprintf ("There are %d lions in the %s", num, location);
  CPPUNIT_ASSERT ( str1 == "There are 3 lions in the zoo" );

  FString str2;
  str2.sprintf (L"It costs only %d cent", 50);
  CPPUNIT_ASSERT ( str2 == "It costs only 50 cent" );

  str2.sprintf ( L"Add a looo" + FString(2048, 'o') + "ooong %S"
               , L"string" );
  CPPUNIT_ASSERT ( str2 == "Add a looo" + FString(2048, 'o')
                           + "ooong string" );
  std::setlocale (LC_NUMERIC, "C");
  FString fnum1, fnum2;

#if defined(__LP64__) || defined(_LP64)
  // 64-bit architecture
  fnum1.setFormatedNumber(0xffffffffffffffff, '\'');
  CPPUNIT_ASSERT ( fnum1 == "18'446'744'073'709'551'615" );

  fnum2.setFormatedNumber(-9223372036854775807);
  CPPUNIT_ASSERT ( fnum2 == "-9 223 372 036 854 775 807" );

  fnum2.setFormatedNumber(long(9223372036854775807), '\0');
  CPPUNIT_ASSERT ( fnum2 == "9 223 372 036 854 775 807" );

  fnum2.setFormatedNumber(uLong(9223372036854775807), '\0');
  CPPUNIT_ASSERT ( fnum2 == "9 223 372 036 854 775 807" );
#else
  // 32-bit architecture
  fnum1.setFormatedNumber(0xffffffff, '\'');
  CPPUNIT_ASSERT ( fnum1 == "4'294'967'295" );

  fnum2.setFormatedNumber(-2147483647);
  CPPUNIT_ASSERT ( fnum2 == "-2 147 483 647" );

  fnum2.setFormatedNumber(long(2147483647), '\0');
  CPPUNIT_ASSERT ( fnum2 == "2 147 483 647" );

  fnum2.setFormatedNumber(uLong(2147483647), '\0');
  CPPUNIT_ASSERT ( fnum2 == "2 147 483 647" );
#endif
}

//----------------------------------------------------------------------
void FStringTest::convertToNumberTest()
{
  FString str = "-127";
  CPPUNIT_ASSERT ( str.toShort() == -127 );

  str = "255";
  CPPUNIT_ASSERT ( str.toUShort() == 255 );

  str = "-32768";
  CPPUNIT_ASSERT ( str.toInt() == -32768 );

  str = "65535";
  CPPUNIT_ASSERT ( str.toUInt() == 65535 );

  str = "-2147483647";
  CPPUNIT_ASSERT ( str.toLong() == -2147483647 );

  str = "+987654321";
  CPPUNIT_ASSERT ( str.toLong() == 987654321 );

  str = "4294967295";
  CPPUNIT_ASSERT ( str.toULong() == 4294967295 );

  str = "+1234567890";
  CPPUNIT_ASSERT ( str.toULong() == 1234567890 );

  str = "3.14159";
  CPPUNIT_ASSERT ( str.toFloat() == 3.14159f );

  str = "-3.14159";
  CPPUNIT_ASSERT ( str.toFloat() == -3.14159f );

  str = "3.141592653589793238";
  CPPUNIT_ASSERT ( str.toDouble() == 3.141592653589793238 );

  str = "-3.141592653589793238";
  CPPUNIT_ASSERT ( str.toDouble() == -3.141592653589793238 );
}

//----------------------------------------------------------------------
void FStringTest::convertFromNumberTest()
{
  const sInt16  n1 = -1234;
  const uInt16  n2 =  1234;
  const int     n3 = -12345;
  const uInt    n4 =  12345;
  const long    n5 = -12345678;
  const uLong   n6 =  12345678;
  const float   n7 =  1234.56f;
  const double  n8 =  1234.5678;
  const lDouble n9 =  12345.67890L;
  CPPUNIT_ASSERT ( FString().setNumber(n1) == "-1234" );
  CPPUNIT_ASSERT ( FString().setNumber(n2) == "1234" );
  CPPUNIT_ASSERT ( FString().setNumber(n3) == "-12345" );
  CPPUNIT_ASSERT ( FString().setNumber(n4) == "12345" );
  CPPUNIT_ASSERT ( FString().setNumber(n5) == "-12345678" );
  CPPUNIT_ASSERT ( FString().setNumber(n6) == "12345678" );
  CPPUNIT_ASSERT ( FString().setNumber(n7) == "1234.56" );
  CPPUNIT_ASSERT ( FString().setNumber(n8) == "1234.5678" );
  CPPUNIT_ASSERT ( FString().setNumber(n9) == "12345.6789" );
  CPPUNIT_ASSERT ( FString().setNumber(n7, 0) == "1e+03" );
  CPPUNIT_ASSERT ( FString().setNumber(n8, 0) == "1e+03" );
  CPPUNIT_ASSERT ( FString().setNumber(n9, 0) == "1e+04" );
  CPPUNIT_ASSERT ( FString().setNumber(n7, 100)
                   == "1234.56005859375" );
  CPPUNIT_ASSERT ( FString().setNumber(n8, 100)
                   == "1234.567800000000033833202905952930450439453125" );
  CPPUNIT_ASSERT ( FString().setNumber(n9, 100)
                   == "12345.67889999999999961488583721802569925785064697265625" );
}

//----------------------------------------------------------------------
void FStringTest::exceptionTest()
{
  CPPUNIT_ASSERT_THROW ( FString("abc").toULong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("abc")[3]
                       , std::out_of_range );

  CPPUNIT_ASSERT_THROW ( FString("abc")[-1]
                       , std::out_of_range );

  CPPUNIT_ASSERT_THROW ( FString("99999").toShort()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-99999").toShort()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString("99999").toUShort()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-1").toUShort()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString("9999999999").toInt()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-9999999999").toInt()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString("9999999999").toUInt()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-1").toUInt()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString("9999999999999999999").toLong()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-9999999999999999999").toLong()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString("99999999999999999999").toULong()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-1").toULong()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString().toLong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("").toLong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("one").toLong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString().toULong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("").toULong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("one").toULong()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("1E+42").toFloat()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-1E+42").toFloat()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("1.19209290E-08").toFloat()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString("1.7976931348623157E+309").toDouble()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("-1.7976931348623157E+309").toDouble()
                       , std::overflow_error );

  CPPUNIT_ASSERT_THROW ( FString("2.225074e-310").toDouble()
                       , std::underflow_error );

  CPPUNIT_ASSERT_THROW ( FString().toDouble()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("").toDouble()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("one").toDouble()
                       , std::invalid_argument );

  CPPUNIT_ASSERT_THROW ( FString("ABC").insert(FString("abc"), 4)
                       , std::out_of_range );

  CPPUNIT_ASSERT_THROW ( FString("ABC").insert(FString("abc"), -1)
                       , std::out_of_range );

  CPPUNIT_ASSERT_THROW ( FString("ABC").insert(L"abc", 4)
                       , std::out_of_range );

  CPPUNIT_ASSERT_THROW ( FString("ABC").insert(L"abc", -1)
                       , std::out_of_range );
}

//----------------------------------------------------------------------
void FStringTest::trimTest()
{
  const FString& trim_str1 = L"\r\n\t  A string \n\t";
  CPPUNIT_ASSERT ( trim_str1.rtrim() == L"\r\n\t  A string" );
  CPPUNIT_ASSERT ( trim_str1.ltrim() == L"A string \n\t" );
  CPPUNIT_ASSERT ( trim_str1.trim() == L"A string" );

  const FString& trim_str2 = L"\n  \n\n";
  CPPUNIT_ASSERT ( trim_str2.rtrim().isEmpty() );
  CPPUNIT_ASSERT ( ! trim_str2.rtrim().isNull() );
  CPPUNIT_ASSERT ( trim_str2.rtrim().getLength() == 0 );

  CPPUNIT_ASSERT ( trim_str2.ltrim().isEmpty() );
  CPPUNIT_ASSERT ( ! trim_str2.ltrim().isNull() );
  CPPUNIT_ASSERT ( trim_str2.ltrim().getLength() == 0 );

  const FString trim_str3;
  CPPUNIT_ASSERT ( trim_str3.ltrim().isEmpty() );
  CPPUNIT_ASSERT ( trim_str3.ltrim().isEmpty() );
  CPPUNIT_ASSERT ( trim_str3.ltrim().getLength() == 0 );
  CPPUNIT_ASSERT ( trim_str3.rtrim().isEmpty() );
  CPPUNIT_ASSERT ( trim_str3.rtrim().isEmpty() );
  CPPUNIT_ASSERT ( trim_str3.rtrim().getLength() == 0 );
  CPPUNIT_ASSERT ( trim_str3.trim().isEmpty() );
  CPPUNIT_ASSERT ( trim_str3.trim().isNull() );
  CPPUNIT_ASSERT ( trim_str3.trim().getLength() == 0 );
}

//----------------------------------------------------------------------
void FStringTest::subStringTest()
{
  FString str1("Look behind you, a three-headed monkey!");
  CPPUNIT_ASSERT ( str1.left(uInt(11)) == L"Look behind" );
  CPPUNIT_ASSERT ( str1.left(int(11)) == L"Look behind" );
  CPPUNIT_ASSERT ( str1.left(999)
                   == L"Look behind you, a three-headed monkey!" );
  CPPUNIT_ASSERT ( str1.left(-5) == L"" );
  CPPUNIT_ASSERT ( str1.left(0) == L"" );
  CPPUNIT_ASSERT ( str1.left(0).isEmpty() );
  CPPUNIT_ASSERT ( ! str1.left(0).isNull() );
  CPPUNIT_ASSERT ( FString().left(5).isNull() );
  CPPUNIT_ASSERT ( ! FString("").left(5).isNull() );
  CPPUNIT_ASSERT ( FString("").left(5).isEmpty() );

  CPPUNIT_ASSERT ( str1.right(uInt(7)) == L"monkey!" );
  CPPUNIT_ASSERT ( str1.right(int(7)) == L"monkey!" );
  CPPUNIT_ASSERT ( str1.right(999)
                   == L"Look behind you, a three-headed monkey!" );
  CPPUNIT_ASSERT ( str1.right(-5) == L"" );
  CPPUNIT_ASSERT ( str1.right(0) == L"" );
  CPPUNIT_ASSERT ( str1.right(0).isEmpty() );
  CPPUNIT_ASSERT ( ! str1.right(0).isNull() );
  CPPUNIT_ASSERT ( FString().right(5).isNull() );
  CPPUNIT_ASSERT ( ! FString("").right(5).isNull() );
  CPPUNIT_ASSERT ( FString("").right(5).isEmpty() );

  CPPUNIT_ASSERT ( str1.mid(uInt(18), uInt(21))
                   == L"a three-headed monkey" );
  CPPUNIT_ASSERT ( str1.mid(int(18), int(21))
                   == L"a three-headed monkey" );
  CPPUNIT_ASSERT ( str1.mid(1, 999)
                   == L"Look behind you, a three-headed monkey!" );
  CPPUNIT_ASSERT ( str1.mid(5, 0) == L"" );
  CPPUNIT_ASSERT ( str1.mid(-5, 2) == L"" );
  CPPUNIT_ASSERT ( str1.mid(0, 0) == L"" );
  CPPUNIT_ASSERT ( str1.mid(0, 5) == L"" );
  CPPUNIT_ASSERT ( str1.mid(0, 0).isEmpty() );
  CPPUNIT_ASSERT ( ! str1.mid(0, 0).isNull() );
  CPPUNIT_ASSERT ( FString().mid(5, 0).isNull() );
  CPPUNIT_ASSERT ( ! FString("").mid(5, 0).isNull() );
  CPPUNIT_ASSERT ( FString("").mid(5, 0).isEmpty() );

  FStringList string_parts = str1.split(" ");
  FStringList string_list;
  string_list.push_back("Look");
  string_list.push_back("behind");
  string_list.push_back("you,");
  string_list.push_back("a");
  string_list.push_back("three-headed");
  string_list.push_back("monkey!");
  CPPUNIT_ASSERT ( string_parts == string_list );

  string_parts = str1.split(L',');
  string_list.clear();
  string_list.push_back("Look behind you");
  string_list.push_back(" a three-headed monkey!");
  CPPUNIT_ASSERT ( string_parts == string_list );

  string_parts = str1.split(',');
  CPPUNIT_ASSERT ( string_parts == string_list );

  string_parts = FString().split(':');
  CPPUNIT_ASSERT ( string_parts.empty() );
  CPPUNIT_ASSERT ( string_parts.size() == 0 );
}

//----------------------------------------------------------------------
void FStringTest::insertTest()
{
  FString str1 = "ABC";
  const FString str2 = "xyz";
  CPPUNIT_ASSERT ( str1.insert(str2, 0) == "xyzABC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str2, 1) == "AxyzBC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str2, 2) == "ABxyzC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str2, 3) == "ABCxyz" );

  str1 = "ABC";
  const wchar_t str3[] = L"xyz";
  CPPUNIT_ASSERT ( str1.insert(str3, 0) == "xyzABC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str3, 1) == "AxyzBC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str3, 2) == "ABxyzC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str3, 3) == "ABCxyz" );

  str1 = "ABC";
  const char str4[] = "xyz";
  CPPUNIT_ASSERT ( str1.insert(str4, 0) == "xyzABC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str4, 1) == "AxyzBC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str4, 2) == "ABxyzC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(str4, 3) == "ABCxyz" );

  str1 = "ABC";
  const wchar_t wc = L'*';
  CPPUNIT_ASSERT ( str1.insert(wc, 0) == "*ABC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(wc, 1) == "A*BC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(wc, 2) == "AB*C" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(wc, 3) == "ABC*" );

  str1 = "ABC";
  const char c = '*';
  CPPUNIT_ASSERT ( str1.insert(c, 0) == "*ABC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(c, 1) == "A*BC" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(c, 2) == "AB*C" );
  str1 = "ABC";
  CPPUNIT_ASSERT ( str1.insert(c, 3) == "ABC*" );
}

//----------------------------------------------------------------------
void FStringTest::replaceTest()
{
  const FString str = "Look behind you, a three-headed monkey!";
  FString s = str;
  const FString      from1   =  "three";
  const std::wstring from2   = L"three";
  const wchar_t      from3[] = L"three";
  const std::string  from4   =  "three";
  const char         from5[] =  "three";
  const wchar_t      from6   = L',';
  const char         from7   =  ',';
  const FString      to1     = L'3';
  const std::wstring to2     = L"3";
  const wchar_t      to3[]   = L"3";
  const std::string  to4     =  "3";
  const char         to5[]   =  "3";
  const wchar_t      to6     =  '3';
  const char         to7     =  '3';

  CPPUNIT_ASSERT ( s.replace(from1, to1)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from1, to2)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from1, to3)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from1, to4)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from1, to5)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from1, to6)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from1, to7)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to1)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to2)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to3)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to4)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to5)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to6)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from2, to7)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to1)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to2)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to3)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to4)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to5)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to6)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from3, to7)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to1)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to2)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to3)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to4)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to5)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to6)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from4, to7)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to1)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to2)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to3)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to4)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to5)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to6)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from5, to7)
                   == "Look behind you, a 3-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to1)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to2)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to3)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to4)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to5)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to6)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from6, to7)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to1)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to2)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to3)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to4)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to5)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to6)
                   == "Look behind you3 a three-headed monkey!" );
  s = str;
  CPPUNIT_ASSERT ( s.replace(from7, to7)
                   == "Look behind you3 a three-headed monkey!" );

  s = "A big ball and a small ball";
  CPPUNIT_ASSERT ( s.replace("ball", "globe")
                   == "A big globe and a small globe" );

  s = "ABC";
  FString empty;
  CPPUNIT_ASSERT ( s.replace(from1, empty) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(from3, empty) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(from5, to5) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(empty, to1) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(from6, empty) == "ABC"  );

  empty = "";
  CPPUNIT_ASSERT ( s.replace(from1, empty) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(from3, empty) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(from5, to5) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(empty, to1) == "ABC" );
  CPPUNIT_ASSERT ( s.replace(from6, empty) == "ABC"  );

  s.clear();
  CPPUNIT_ASSERT ( s.replace(from1, to1).isNull() );
  CPPUNIT_ASSERT ( s.replace(from1, to1).isEmpty() );
  CPPUNIT_ASSERT ( s.replace(from6, to1).isNull() );
  CPPUNIT_ASSERT ( s.replace(from6, to1).isEmpty() );

  CPPUNIT_ASSERT ( s.replace(from5, to5).isNull() );
  CPPUNIT_ASSERT ( s.replace(from5, to5).isEmpty() );
  CPPUNIT_ASSERT ( s.replace(from7, to7).isNull() );
  CPPUNIT_ASSERT ( s.replace(from7, to7).isEmpty() );
}

//----------------------------------------------------------------------
void FStringTest::overwriteTest()
{
  // FString
  FString str = "abcdefghijklm";
  CPPUNIT_ASSERT ( str.overwrite("+++++++", 3) == "abc+++++++klm" );
  CPPUNIT_ASSERT ( str.overwrite(".............") == "............." );
  CPPUNIT_ASSERT ( str.overwrite(",,,,,,,,,,,,,,,") == ",,,,,,,,,,,,,,," );
  str = "abc";
  CPPUNIT_ASSERT ( str.overwrite("+++++", 99) == "abc+++++" );
  str = "abc";
  CPPUNIT_ASSERT ( str.overwrite("+++", -5) == "+++" );

  // Wide string
  str = "abcdefghijklm";
  CPPUNIT_ASSERT ( str.overwrite(L"+++++++", 3) == "abc+++++++klm" );
  CPPUNIT_ASSERT ( str.overwrite(L".............") == "............." );
  CPPUNIT_ASSERT ( str.overwrite(L",,,,,,,,,,,,,,,") == ",,,,,,,,,,,,,,," );
  str = "abc";
  CPPUNIT_ASSERT ( str.overwrite(L"+++++", 99) == "abc+++++" );
  str = "abc";
  CPPUNIT_ASSERT ( str.overwrite(L"+++", -5) == "+++" );

  // Wide char
  str = "abcdefghijklm";
  CPPUNIT_ASSERT ( str.overwrite(L'+', 3) == "abc+efghijklm" );
  CPPUNIT_ASSERT ( str.overwrite(L'.') == ".bc+efghijklm" );
  CPPUNIT_ASSERT ( str.overwrite(L',', 12) == ".bc+efghijkl," );
  CPPUNIT_ASSERT ( str.overwrite(L'.', 13) == ".bc+efghijkl,." );
  str = "abc";
  CPPUNIT_ASSERT ( str.overwrite(L'+', 99) == "abc+" );
  str = "abc";
  CPPUNIT_ASSERT ( str.overwrite(L'+', -5) == "+bc" );
}

//----------------------------------------------------------------------
void FStringTest::removeTest()
{
  FString str = "ABCDE";
  CPPUNIT_ASSERT ( str.remove(2, 2) == "ABE" );
  CPPUNIT_ASSERT ( str.remove(2, 1) == "AB" );
  CPPUNIT_ASSERT ( str.remove(2, 1) == "AB" );
  CPPUNIT_ASSERT ( str.remove(2, 5) == "AB" );
  str = "ABCDE";
  CPPUNIT_ASSERT ( str.remove(2, 99) == "AB" );
  CPPUNIT_ASSERT ( str.remove(99, 1) == "AB" );
}

//----------------------------------------------------------------------
void FStringTest::includesTest()
{
  const FString str = "Look behind you, a three-headed monkey!";
  const FString empty1;
  const wchar_t empty2[] = L"";
  const char empty3[] = "";
  const FString search1 = "you";
  const FString search2 = "me";
  const wchar_t search3[] = L"you";
  const wchar_t search4[] = L"me";
  const char search5[] = "you";
  const char search6[] = "me";
  const wchar_t search7 = L'y';
  const wchar_t search8 = L'&';
  const char search9 = 'y';
  const char search10 = '&';

  CPPUNIT_ASSERT ( ! str.includes(static_cast<FString>(0)) );
  CPPUNIT_ASSERT ( ! str.includes(empty1) );
  CPPUNIT_ASSERT ( str.includes(search1) );
  CPPUNIT_ASSERT ( ! str.includes(search2) );
  CPPUNIT_ASSERT ( ! empty1.includes(search1) );

  CPPUNIT_ASSERT ( ! str.includes(static_cast<wchar_t*>(0)) );
  CPPUNIT_ASSERT ( ! str.includes(empty2) );
  CPPUNIT_ASSERT ( str.includes(search3) );
  CPPUNIT_ASSERT ( ! str.includes(search4) );
  CPPUNIT_ASSERT ( ! empty1.includes(search3) );

  CPPUNIT_ASSERT ( ! str.includes(static_cast<char*>(0)) );
  CPPUNIT_ASSERT ( ! str.includes(empty3) );
  CPPUNIT_ASSERT ( str.includes(search5) );
  CPPUNIT_ASSERT ( ! str.includes(search6) );
  CPPUNIT_ASSERT ( ! empty1.includes(search5) );

  CPPUNIT_ASSERT ( ! str.includes(wchar_t(L'\0')) );
  CPPUNIT_ASSERT ( str.includes(search7) );
  CPPUNIT_ASSERT ( ! str.includes(search8) );
  CPPUNIT_ASSERT ( ! empty1.includes(search7) );

  CPPUNIT_ASSERT ( ! str.includes(char('\0')) );
  CPPUNIT_ASSERT ( str.includes(search9) );
  CPPUNIT_ASSERT ( ! str.includes(search10) );
  CPPUNIT_ASSERT ( ! empty1.includes(search9) );
}

//----------------------------------------------------------------------
void FStringTest::controlCodesTest()
{
  FString bs_str = "t\b\bTesT\bt";
  CPPUNIT_ASSERT ( bs_str.removeBackspaces() == "Test" );
  bs_str = "ABC\b\b\b\b";
  CPPUNIT_ASSERT ( bs_str.removeBackspaces() == "" );
  CPPUNIT_ASSERT ( bs_str.removeBackspaces().isEmpty() );

  FString del_str = "apple \177\177\177pietree";
  CPPUNIT_ASSERT ( del_str.removeDel() == "apple tree" );
  del_str = "\177\177\177\177ABC";
  CPPUNIT_ASSERT ( del_str.removeDel() == "" );
  CPPUNIT_ASSERT ( del_str.removeDel().isEmpty() );

  FString tab_str = "one line";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "one line" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "one line" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "one line" );
  tab_str = "one\ttwo";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "one     two" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "one two" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "one two" );
  tab_str = "one\t\btwo";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "one     \btwo" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "one \btwo" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "one \btwo" );
  tab_str = "1\t2\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "1       2       2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "1   2   2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "1 2 2" );
  tab_str = "12\t22\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "12      22      2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "12  22  2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "12  22  2" );
  tab_str = "123\t222\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "123     222     2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "123 222 2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "123 222 2" );
  tab_str = "1234\t2222\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "1234    2222    2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "1234    2222    2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "1234  2222  2" );
  tab_str = "12345\t22222\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "12345   22222   2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "12345   22222   2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "12345 22222 2" );
  tab_str = "123456\t222222\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "123456  222222  2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "123456  222222  2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "123456  222222  2" );
  tab_str = "1234567\t2222222\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "1234567 2222222 2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "1234567 2222222 2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "1234567 2222222 2" );
  tab_str = "12345678\t22222222\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs()
                   == "12345678        22222222        2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4)
                   == "12345678    22222222    2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2)
                   == "12345678  22222222  2" );
  tab_str = "12345678\t2";
  CPPUNIT_ASSERT ( tab_str.expandTabs() == "12345678        2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(4) == "12345678    2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(2) == "12345678  2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(0) == "12345678\t2" );
  CPPUNIT_ASSERT ( tab_str.expandTabs(-1) == "12345678\t2" );
  FString cc(0x20);

  for (int i = 0; i < 0x1f; i++)
    cc[i] = i + 1;

  CPPUNIT_ASSERT ( cc.replaceControlCodes()
                   == "␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟" );

  for (int i = 0; i <= 0x1f; i++)
    cc[i] = i + 0x80;

  CPPUNIT_ASSERT ( cc.replaceControlCodes() == FString(32, L' ') );

  cc = "t\b\bTes\177Tt";
  CPPUNIT_ASSERT ( cc.replaceControlCodes() == "t␈␈Tes␡Tt" );
}

// Put the test suite in the registry
CPPUNIT_TEST_SUITE_REGISTRATION (FStringTest);

// The general unit test main part
#include <main-test.inc>