graphics context additions and merging graphics bitmap additions from Kevin O.

[wxWidgets.git] / tests / strings / strings.cpp

diff --git a/tests/strings/strings.cpp b/tests/strings/strings.cpp
index 322735ee3861c04d68c727b9eeeb71c584cb3e3f..e56d7e9a25a7c54e93232616a9bc560ba630de9d 100644 (file)
--- a/tests/strings/strings.cpp
+++ b/tests/strings/strings.cpp
@@ -11,7 +11,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#include "wx/wxprec.h"
+#include "testprec.h"

 
 #ifdef __BORLANDC__
     #pragma hdrstop
 
 #ifdef __BORLANDC__
     #pragma hdrstop


@@ -21,10 +21,6 @@
     #include "wx/wx.h"
 #endif // WX_PRECOMP
 
     #include "wx/wx.h"
 #endif // WX_PRECOMP
 

-#include "wx/tokenzr.h"
-
-#include "wx/cppunit.h"
-

 // ----------------------------------------------------------------------------
 // test class
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // test class
 // ----------------------------------------------------------------------------


@@ -40,24 +36,59 @@ private:
         CPPUNIT_TEST( PChar );
         CPPUNIT_TEST( Format );
         CPPUNIT_TEST( Constructors );
         CPPUNIT_TEST( PChar );
         CPPUNIT_TEST( Format );
         CPPUNIT_TEST( Constructors );

+        CPPUNIT_TEST( StaticConstructors );

         CPPUNIT_TEST( Extraction );
         CPPUNIT_TEST( Extraction );

+        CPPUNIT_TEST( Trim );

         CPPUNIT_TEST( Find );
         CPPUNIT_TEST( Find );

-        CPPUNIT_TEST( Tokenizer );

         CPPUNIT_TEST( Replace );
         CPPUNIT_TEST( Match );
         CPPUNIT_TEST( Replace );
         CPPUNIT_TEST( Match );

-        CPPUNIT_TEST( Std );
+        CPPUNIT_TEST( CaseChanges );
+        CPPUNIT_TEST( Compare );
+        CPPUNIT_TEST( CompareNoCase );
+        CPPUNIT_TEST( Contains );
+        CPPUNIT_TEST( ToLong );
+        CPPUNIT_TEST( ToULong );
+#ifdef wxLongLong_t
+        CPPUNIT_TEST( ToLongLong );
+        CPPUNIT_TEST( ToULongLong );
+#endif // wxLongLong_t
+        CPPUNIT_TEST( ToDouble );
+        CPPUNIT_TEST( WriteBuf );
+        CPPUNIT_TEST( UTF8Buf );
+        CPPUNIT_TEST( CStrDataTernaryOperator );
+        CPPUNIT_TEST( CStrDataOperators );
+        CPPUNIT_TEST( CStrDataImplicitConversion );
+        CPPUNIT_TEST( ExplicitConversion );

     CPPUNIT_TEST_SUITE_END();
 
     void String();
     void PChar();
     void Format();
     void Constructors();
     CPPUNIT_TEST_SUITE_END();
 
     void String();
     void PChar();
     void Format();
     void Constructors();

+    void StaticConstructors();

     void Extraction();
     void Extraction();

+    void Trim();

     void Find();
     void Find();

-    void Tokenizer();

     void Replace();
     void Match();
     void Replace();
     void Match();

-    void Std();
+    void CaseChanges();
+    void Compare();
+    void CompareNoCase();
+    void Contains();
+    void ToLong();
+    void ToULong();
+#ifdef wxLongLong_t
+    void ToLongLong();
+    void ToULongLong();
+#endif // wxLongLong_t
+    void ToDouble();
+    void WriteBuf();
+    void UTF8Buf();
+    void CStrDataTernaryOperator();
+    void DoCStrDataTernaryOperator(bool cond);
+    void CStrDataOperators();
+    void CStrDataImplicitConversion();
+    void ExplicitConversion();

 
     DECLARE_NO_COPY_CLASS(StringTestCase)
 };
 
     DECLARE_NO_COPY_CLASS(StringTestCase)
 };


@@ -117,24 +148,61 @@ void StringTestCase::Format()
     CPPUNIT_ASSERT( s1 == wxString::Format(_T("%03d"), 18) );
     s2.Printf(_T("Number 18: %s\n"), s1.c_str());
     CPPUNIT_ASSERT( s2 == wxString::Format(_T("Number 18: %s\n"), s1.c_str()) );
     CPPUNIT_ASSERT( s1 == wxString::Format(_T("%03d"), 18) );
     s2.Printf(_T("Number 18: %s\n"), s1.c_str());
     CPPUNIT_ASSERT( s2 == wxString::Format(_T("Number 18: %s\n"), s1.c_str()) );

+
+    static const size_t lengths[] = { 1, 512, 1024, 1025, 2048, 4096, 4097 };
+    for ( size_t n = 0; n < WXSIZEOF(lengths); n++ )
+    {
+        const size_t len = lengths[n];
+
+        wxString s(_T('Z'), len);
+        CPPUNIT_ASSERT_EQUAL( len, wxString::Format(_T("%s"), s.c_str()).length());
+    }

 }
 
 void StringTestCase::Constructors()
 {
 }
 
 void StringTestCase::Constructors()
 {

-    #define TEST_CTOR(args, res)                                               \
-        {                                                                      \
-            wxString s args ;                                                  \
-            CPPUNIT_ASSERT( s == res );                                        \
-        }
+    WX_ASSERT_STR_EQUAL( "", wxString('Z', 0) );
+    WX_ASSERT_STR_EQUAL( "Z", wxString('Z') );
+    WX_ASSERT_STR_EQUAL( "ZZZZ", wxString('Z', 4) );
+    WX_ASSERT_STR_EQUAL( "Hell", wxString("Hello", 4) );
+    WX_ASSERT_STR_EQUAL( "Hello", wxString("Hello", 5) );
+
+#if wxUSE_UNICODE
+    WX_ASSERT_STR_EQUAL( L"", wxString(L'Z', 0) );
+    WX_ASSERT_STR_EQUAL( L"Z", wxString(L'Z') );
+    WX_ASSERT_STR_EQUAL( L"ZZZZ", wxString(L'Z', 4) );
+    WX_ASSERT_STR_EQUAL( L"Hell", wxString(L"Hello", 4) );
+    WX_ASSERT_STR_EQUAL( L"Hello", wxString(L"Hello", 5) );
+#endif // wxUSE_UNICODE
+
+    static const char *s = "?really!";
+    const char *start = wxStrchr(s, 'r');
+    const char *end = wxStrchr(s, '!');
+    WX_ASSERT_STR_EQUAL( "really", wxString(start, end) );
+
+    // test if creating string from NULL C pointer works:
+    WX_ASSERT_STR_EQUAL( "", wxString((const char *)NULL) );
+}
+
+void StringTestCase::StaticConstructors()
+{
+    WX_ASSERT_STR_EQUAL( "", wxString::FromAscii("") );
+    WX_ASSERT_STR_EQUAL( "", wxString::FromAscii("Hello", 0) );
+    WX_ASSERT_STR_EQUAL( "Hell", wxString::FromAscii("Hello", 4) );
+    WX_ASSERT_STR_EQUAL( "Hello", wxString::FromAscii("Hello", 5) );
+    WX_ASSERT_STR_EQUAL( "Hello", wxString::FromAscii("Hello") );
+
+    // FIXME: this doesn't work currently but should!
+    //WX_ASSERT_SIZET_EQUAL( 1, wxString::FromAscii("", 1).length() );
+

 
 

-    TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
-    TEST_CTOR((_T("Hello"), 4), _T("Hell"));
-    TEST_CTOR((_T("Hello"), 5), _T("Hello"));
+    WX_ASSERT_STR_EQUAL( "", wxString::FromUTF8("") );
+    WX_ASSERT_STR_EQUAL( "", wxString::FromUTF8("Hello", 0) );
+    WX_ASSERT_STR_EQUAL( "Hell", wxString::FromUTF8("Hello", 4) );
+    WX_ASSERT_STR_EQUAL( "Hello", wxString::FromUTF8("Hello", 5) );
+    WX_ASSERT_STR_EQUAL( "Hello", wxString::FromUTF8("Hello") );

 
 

-    static const wxChar *s = _T("?really!");
-    const wxChar *start = wxStrchr(s, _T('r'));
-    const wxChar *end = wxStrchr(s, _T('!'));
-    TEST_CTOR((start, end), _T("really"));
+    //WX_ASSERT_SIZET_EQUAL( 1, wxString::FromUTF8("", 1).length() );

 }
 
 void StringTestCase::Extraction()
 }
 
 void StringTestCase::Extraction()


@@ -149,13 +217,20 @@ void StringTestCase::Extraction()
     CPPUNIT_ASSERT( wxStrcmp( s.substr(3, 5).c_str() , _T("lo, w") ) == 0 );
     CPPUNIT_ASSERT( wxStrcmp( s.substr(3).c_str() , _T("lo, world!") ) == 0 );
 
     CPPUNIT_ASSERT( wxStrcmp( s.substr(3, 5).c_str() , _T("lo, w") ) == 0 );
     CPPUNIT_ASSERT( wxStrcmp( s.substr(3).c_str() , _T("lo, world!") ) == 0 );
 

+#if wxUSE_UNICODE
+    static const char *germanUTF8 = "Oberfl\303\244che";
+    wxString strUnicode(wxString::FromUTF8(germanUTF8));
+
+    CPPUNIT_ASSERT( strUnicode.Mid(0, 10) == strUnicode );
+    CPPUNIT_ASSERT( strUnicode.Mid(7, 2) == "ch" );
+#endif // wxUSE_UNICODE
+

     wxString rest;
 
     wxString rest;
 

-    #define TEST_STARTS_WITH( prefix , correct_rest, result ) \
-        CPPUNIT_ASSERT( \
-            ( s.StartsWith( prefix, &rest ) == result ) && \
-            ( ( result == false ) || ( wxStrcmp( correct_rest , rest ) == 0 ) ) \
-        )
+    #define TEST_STARTS_WITH(prefix, correct_rest, result)                    \
+        CPPUNIT_ASSERT_EQUAL(result, s.StartsWith(prefix, &rest));            \
+        if ( result )                                                         \
+            WX_ASSERT_STR_EQUAL(correct_rest, rest)

 
     TEST_STARTS_WITH( _T("Hello"),           _T(", world!"),      true  );
     TEST_STARTS_WITH( _T("Hello, "),         _T("world!"),        true  );
 
     TEST_STARTS_WITH( _T("Hello"),           _T(", world!"),      true  );
     TEST_STARTS_WITH( _T("Hello, "),         _T("world!"),        true  );


@@ -166,6 +241,45 @@ void StringTestCase::Extraction()
     TEST_STARTS_WITH( _T("Hi"),              _T(""),              false );
 
     #undef TEST_STARTS_WITH
     TEST_STARTS_WITH( _T("Hi"),              _T(""),              false );
 
     #undef TEST_STARTS_WITH

+
+    rest = "Hello world";
+    CPPUNIT_ASSERT( rest.StartsWith("Hello ", &rest) );
+    WX_ASSERT_STR_EQUAL("world", rest);
+
+    #define TEST_ENDS_WITH(suffix, correct_rest, result)                      \
+        CPPUNIT_ASSERT_EQUAL(result, s.EndsWith(suffix, &rest));              \
+        if ( result )                                                         \
+            WX_ASSERT_STR_EQUAL(correct_rest, rest)
+
+    TEST_ENDS_WITH( _T(""),                 _T("Hello, world!"), true  );
+    TEST_ENDS_WITH( _T("!"),                _T("Hello, world"),  true  );
+    TEST_ENDS_WITH( _T(", world!"),         _T("Hello"),         true  );
+    TEST_ENDS_WITH( _T("ello, world!"),     _T("H"),             true  );
+    TEST_ENDS_WITH( _T("Hello, world!"),    _T(""),              true  );
+    TEST_ENDS_WITH( _T("very long string"), _T(""),              false );
+    TEST_ENDS_WITH( _T("?"),                _T(""),              false );
+    TEST_ENDS_WITH( _T("Hello, world"),     _T(""),              false );
+    TEST_ENDS_WITH( _T("Gello, world!"),    _T(""),              false );
+
+    #undef TEST_ENDS_WITH
+}
+
+void StringTestCase::Trim()
+{
+    #define TEST_TRIM( str , dir , result )  \
+        CPPUNIT_ASSERT( wxString(str).Trim(dir) == result )
+
+    TEST_TRIM( _T("  Test  "),  true, _T("  Test") );
+    TEST_TRIM( _T("    "),      true, _T("")       );
+    TEST_TRIM( _T(" "),         true, _T("")       );
+    TEST_TRIM( _T(""),          true, _T("")       );
+
+    TEST_TRIM( _T("  Test  "),  false, _T("Test  ") );
+    TEST_TRIM( _T("    "),      false, _T("")       );
+    TEST_TRIM( _T(" "),         false, _T("")       );
+    TEST_TRIM( _T(""),          false, _T("")       );
+
+    #undef TEST_TRIM

 }
 
 void StringTestCase::Find()
 }
 
 void StringTestCase::Find()


@@ -180,69 +294,13 @@ void StringTestCase::Find()
     #undef TEST_FIND
 }
 
     #undef TEST_FIND
 }
 

-void StringTestCase::Tokenizer()
-{
-    #define TEST_TOKENIZER( str , delims, count , mode )  \
-        {                                                 \
-            wxStringTokenizer tkz( str, delims, mode);    \
-            CPPUNIT_ASSERT( tkz.CountTokens() == count ); \
-                                                          \
-            wxChar *buf, *s = NULL, *last;                \
-                                                          \
-            if ( tkz.GetMode() == wxTOKEN_STRTOK )        \
-            {                                             \
-                buf = new wxChar[wxStrlen(str) + 1];      \
-                wxStrcpy(buf, str);                       \
-                s = wxStrtok(buf, delims, &last);         \
-            }                                             \
-            else                                          \
-            {                                             \
-                buf = NULL;                               \
-            }                                             \
-                                                          \
-            size_t count2 = 0;                            \
-            while ( tkz.HasMoreTokens() )                 \
-            {                                             \
-                wxString token = tkz.GetNextToken();      \
-                if ( buf )                                \
-                {                                         \
-                    CPPUNIT_ASSERT( token == s );         \
-                    s = wxStrtok(NULL, delims, &last);    \
-                }                                         \
-                count2++;                                 \
-            }                                             \
-                                                          \
-            CPPUNIT_ASSERT( count2 == count );            \
-            if ( buf )                                    \
-            {                                             \
-                delete [] buf;                            \
-            }                                             \
-        }
-
-    TEST_TOKENIZER( _T(""),                                           _T(" "),              0, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("Hello, world"),                               _T(" "),              2, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("Hello,   world  "),                           _T(" "),              2, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("Hello, world"),                               _T(","),              2, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("Hello, world!"),                              _T(",!"),             2, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("Hello,, world!"),                             _T(",!"),             3, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("Hello, world!"),                              _T(",!"),             3, wxTOKEN_RET_EMPTY_ALL );
-    TEST_TOKENIZER( _T("username:password:uid:gid:gecos:home:shell"), _T(":"),              7, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("1 \t3\t4  6   "),                             wxDEFAULT_DELIMITERS, 4, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("1 \t3\t4  6   "),                             wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY     );
-    TEST_TOKENIZER( _T("1 \t3\t4  6   "),                             wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL );
-    TEST_TOKENIZER( _T("01/02/99"),                                   _T("/-"),             3, wxTOKEN_DEFAULT       );
-    TEST_TOKENIZER( _T("01-02/99"),                                   _T("/-"),             3, wxTOKEN_RET_DELIMS    );
-
-    #undef TEST_TOKENIZER
-}
-

 void StringTestCase::Replace()
 {
     #define TEST_REPLACE( original , pos , len , replacement , result ) \
         { \
             wxString s = original; \
             s.replace( pos , len , replacement ); \
 void StringTestCase::Replace()
 {
     #define TEST_REPLACE( original , pos , len , replacement , result ) \
         { \
             wxString s = original; \
             s.replace( pos , len , replacement ); \

-            CPPUNIT_ASSERT( s == result ); \
+            WX_ASSERT_STR_EQUAL( result, s ); \

         }
 
     TEST_REPLACE( _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"),  _T("012-BWORD-XYZ") );
         }
 
     TEST_REPLACE( _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"),  _T("012-BWORD-XYZ") );


@@ -251,6 +309,32 @@ void StringTestCase::Replace()
     TEST_REPLACE( _T("foobar"),        3, 0, _T("-"),      _T("foo-bar")       );
     TEST_REPLACE( _T("barfoo"),        0, 6, _T("foobar"), _T("foobar")        );
 
     TEST_REPLACE( _T("foobar"),        3, 0, _T("-"),      _T("foo-bar")       );
     TEST_REPLACE( _T("barfoo"),        0, 6, _T("foobar"), _T("foobar")        );
 

+    
+    #define TEST_NULLCHARREPLACE( o , olen, pos , len , replacement , r, rlen ) \
+        { \
+            wxString s(o,olen); \
+            s.replace( pos , len , replacement ); \
+            CPPUNIT_ASSERT( s == wxString(r,rlen) ); \
+        }
+    
+    TEST_NULLCHARREPLACE( _T("null\0char"), 9, 5, 1, _T("d"), 
+                          _T("null\0dhar"), 9 );   
+
+    #define TEST_WXREPLACE( o , olen, olds, news, all, r, rlen ) \
+        { \
+            wxString s(o,olen); \
+            s.Replace( olds, news, all ); \
+            CPPUNIT_ASSERT( s == wxString(r,rlen) ); \
+        }
+    
+    TEST_WXREPLACE( _T("null\0char"), 9, _T("c"), _T("de"), true,
+                          _T("null\0dehar"), 10 );   
+
+    TEST_WXREPLACE( _T("null\0dehar"), 10, _T("de"), _T("c"), true,
+                          _T("null\0char"), 9 );   
+
+    #undef TEST_WXREPLACE
+    #undef TEST_NULLCHARREPLACE

     #undef TEST_REPLACE
 }
 
     #undef TEST_REPLACE
 }
 


@@ -274,256 +358,454 @@ void StringTestCase::Match()
     #undef TEST_MATCH
 }
 
     #undef TEST_MATCH
 }
 

-void StringTestCase::Std()
-{
-    wxString s1(_T("abcdefgh")),
-             s2(_T("abcdefghijklm"), 8),
-             s3(_T("abcdefghijklm")),
-             s4(8, _T('a'));
-    wxString s5(s1),
-             s6(s3, 0, 8),
-             s7(s3.begin(), s3.begin() + 8);
-    wxString s8(s1, 4, 8), s9, s10, s11;
-
-    CPPUNIT_ASSERT( s1 == _T("abcdefgh") );
-    CPPUNIT_ASSERT( s2 == s1 );
-    CPPUNIT_ASSERT( s4 == _T("aaaaaaaa") );
-    CPPUNIT_ASSERT( s5 == _T("abcdefgh") );
-    CPPUNIT_ASSERT( s6 == s1 );
-    CPPUNIT_ASSERT( s7 == s1 );
-    CPPUNIT_ASSERT( s8 == _T("efgh") );
-
-    // test append
-    s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("abc");
-    s1.append(_T("def"));
-    s2.append(_T("defgh"), 3);
-    s3.append(wxString(_T("abcdef")), 3, 6);
-    s4.append(s1);
-    s5.append(3, _T('a'));
-    s6.append(s1.begin() + 3, s1.end());
-
-    CPPUNIT_ASSERT( s1 == _T("abcdef") );
-    CPPUNIT_ASSERT( s2 == _T("abcdef") );
-    CPPUNIT_ASSERT( s3 == _T("abcdef") );
-    CPPUNIT_ASSERT( s4 == _T("abcabcdef") );
-    CPPUNIT_ASSERT( s5 == _T("abcaaa") );
-    CPPUNIT_ASSERT( s6 == _T("abcdef") );
-
-    // test assign
-    s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("abc");
-    s1.assign(_T("def"));
-    s2.assign(_T("defgh"), 3);
-    s3.assign(wxString(_T("abcdef")), 3, 6);
-    s4.assign(s1);
-    s5.assign(3, _T('a'));
-    s6.assign(s1.begin() + 1, s1.end());
-
-    CPPUNIT_ASSERT( s1 == _T("def") );
-    CPPUNIT_ASSERT( s2 == _T("def") );
-    CPPUNIT_ASSERT( s3 == _T("def") );
-    CPPUNIT_ASSERT( s4 == _T("def") );
-    CPPUNIT_ASSERT( s5 == _T("aaa") );
-    CPPUNIT_ASSERT( s6 == _T("ef") );
-
-    // test compare
-    s1 = _T("abcdefgh");
-    s2 = _T("abcdefgh");
-    s3 = _T("abc");
-    s4 = _T("abcdefghi");
-    s5 = _T("aaa");
-    s6 = _T("zzz");
-    s7 = _T("zabcdefg");
-
-    CPPUNIT_ASSERT( s1.compare(s2) == 0 );
-    CPPUNIT_ASSERT( s1.compare(s3) > 0 );
-    CPPUNIT_ASSERT( s1.compare(s4) < 0 );
-    CPPUNIT_ASSERT( s1.compare(s5) > 0 );
-    CPPUNIT_ASSERT( s1.compare(s6) < 0 );
-    CPPUNIT_ASSERT( s1.compare(1, 12, s1) > 0);
-    CPPUNIT_ASSERT( s1.compare(_T("abcdefgh")) == 0);
-    CPPUNIT_ASSERT( s1.compare(1, 7, _T("bcdefgh")) == 0);
-    CPPUNIT_ASSERT( s1.compare(1, 7, _T("bcdefgh"), 7) == 0);
-
-    // test erase
-    s1.erase(1, 1);
-    s2.erase(4, 12);
-    wxString::iterator it = s3.erase(s3.begin() + 1);
-    wxString::iterator it2 = s4.erase(s4.begin() + 4, s4.begin() + 6);
-    wxString::iterator it3 = s7.erase(s7.begin() + 4, s7.begin() + 8);
-
-    CPPUNIT_ASSERT( s1 == _T("acdefgh") );
-    CPPUNIT_ASSERT( s2 == _T("abcd") );
-    CPPUNIT_ASSERT( s3 == _T("ac") );
-    CPPUNIT_ASSERT( s4 == _T("abcdghi") );
-    CPPUNIT_ASSERT( s7 == _T("zabc") );
-    CPPUNIT_ASSERT( *it == _T('c') );
-    CPPUNIT_ASSERT( *it2 == _T('g') );
-    CPPUNIT_ASSERT( it3 == s7.end() );
-
-    // find
-    //       0         1         2
-    //       01234567890123456789012345
-    s1 = _T("abcdefgABCDEFGabcABCabcABC");
-    s2 = _T("gAB");
-
-    CPPUNIT_ASSERT( s1.find(_T('A')) == 7u );
-    CPPUNIT_ASSERT( s1.find(_T('A'), 7) == 7u );
-    CPPUNIT_ASSERT( s1.find(_T('Z')) == wxString::npos );
-    CPPUNIT_ASSERT( s1.find(_T('C'), 22) == 25u );
-
-    CPPUNIT_ASSERT( s1.find(_T("gAB")) == 6u );
-    CPPUNIT_ASSERT( s1.find(_T("gAB"), 7) == wxString::npos );
-    CPPUNIT_ASSERT( s1.find(_T("gAB"), 6) == 6u );
-
-    CPPUNIT_ASSERT( s1.find(_T("gABZZZ"), 2, 3) == 6u );
-    CPPUNIT_ASSERT( s1.find(_T("gABZZZ"), 7, 3) == wxString::npos );
-
-    CPPUNIT_ASSERT( s1.find(s2) == 6u );
-    CPPUNIT_ASSERT( s1.find(s2, 7) == wxString::npos );
-    CPPUNIT_ASSERT( s1.find(s2, 6) == 6u );
-
-    // find_first_not_of
-    //       0         1         2         3
-    //       01234567890123456789012345678901234
-    s1 = _T("aaaaaabcdefghlkjiaaaaaabcdbcdbcdbcd");
-    s2 = _T("aaaaaa");
-
-    CPPUNIT_ASSERT( s1.find_first_not_of(_T('a')) == 6u );
-    CPPUNIT_ASSERT( s1.find_first_not_of(_T('a'), 7) == 7u );
-    CPPUNIT_ASSERT( s2.find_first_not_of(_T('a')) == wxString::npos );
-
-    CPPUNIT_ASSERT( s1.find_first_not_of(_T("abde"), 4) == 7u );
-    CPPUNIT_ASSERT( s1.find_first_not_of(_T("abde"), 7) == 7u );
-    CPPUNIT_ASSERT( s1.find_first_not_of(_T("abcdefghijkl")) == wxString::npos );
-
-    CPPUNIT_ASSERT( s1.find_first_not_of(_T("abcdefghi"), 0, 4) == 9u );
-
-    // find_first_of
-    CPPUNIT_ASSERT( s1.find_first_of(_T('c')) == 7u );
-    CPPUNIT_ASSERT( s1.find_first_of(_T('v')) == wxString::npos );
-    CPPUNIT_ASSERT( s1.find_first_of(_T('c'), 10) == 24u );
-
-    CPPUNIT_ASSERT( s1.find_first_of(_T("ijkl")) == 13u );
-    CPPUNIT_ASSERT( s1.find_first_of(_T("ddcfg"), 17) == 24u );
-    CPPUNIT_ASSERT( s1.find_first_of(_T("ddcfga"), 17, 5) == 24u );
-
-    // find_last_not_of
-    //       0         1         2         3
-    //       01234567890123456789012345678901234
-    s1 = _T("aaaaaabcdefghlkjiaaaaaabcdbcdbcdbcd");
-    s2 = _T("aaaaaa");
-
-    CPPUNIT_ASSERT( s2.find_last_not_of(_T('a')) == wxString::npos );
-    CPPUNIT_ASSERT( s1.find_last_not_of(_T('d')) == 33u );
-    CPPUNIT_ASSERT( s1.find_last_not_of(_T('d'), 25) == 24u );
-
-    CPPUNIT_ASSERT( s1.find_last_not_of(_T("bcd")) == 22u );
-    CPPUNIT_ASSERT( s1.find_last_not_of(_T("abc"), 24) == 16u );
-
-    CPPUNIT_ASSERT( s1.find_last_not_of(_T("abcdefghijklmnopqrstuv"), 24, 3) == 16u );
-
-    // find_last_of
-    CPPUNIT_ASSERT( s2.find_last_of(_T('c')) == wxString::npos );
-    CPPUNIT_ASSERT( s1.find_last_of(_T('a')) == 22u );
-    CPPUNIT_ASSERT( s1.find_last_of(_T('b'), 24) == 23u );
-
-    CPPUNIT_ASSERT( s1.find_last_of(_T("ijklm")) == 16u );
-    CPPUNIT_ASSERT( s1.find_last_of(_T("ijklma"), 33, 4) == 16u );
-    CPPUNIT_ASSERT( s1.find_last_of(_T("a"), 17) == 17u );
-
-    // test insert
-    s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("aaaa");
-    s9 = s10 = _T("cdefg");
-
-    s1.insert(1, _T("cc") );
-    s2.insert(2, _T("cdef"), 3);
-    s3.insert(2, s10);
-    s4.insert(2, s10, 3, 7);
-    s5.insert(1, 2, _T('c'));
-    it = s6.insert(s6.begin() + 3, _T('X'));
-    s7.insert(s7.begin(), s9.begin(), s9.end() - 1);
-    s8.insert(s8.begin(), 2, _T('c'));
-
-    CPPUNIT_ASSERT( s1 == _T("accaaa") );
-    CPPUNIT_ASSERT( s2 == _T("aacdeaa") );
-    CPPUNIT_ASSERT( s3 == _T("aacdefgaa") );
-    CPPUNIT_ASSERT( s4 == _T("aafgaa") );
-    CPPUNIT_ASSERT( s5 == _T("accaaa") );
-    CPPUNIT_ASSERT( s6 == _T("aaaXa") );
-    CPPUNIT_ASSERT( s7 == _T("cdefaaaa") );
-    CPPUNIT_ASSERT( s8 == _T("ccaaaa") );
-
-    s1 = s2 = s3 = _T("aaaa");
-    s1.insert(0, _T("ccc"), 2);
-    s2.insert(4, _T("ccc"), 2);
-
-    CPPUNIT_ASSERT( s1 == _T("ccaaaa") );
-    CPPUNIT_ASSERT( s2 == _T("aaaacc") );
-
-    // test replace
-    s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("QWERTYUIOP");
-    s9 = s10 = _T("werty");
-
-    s1.replace(3, 4, _T("rtyu"));
-    s1.replace(8, 7, _T("opopop"));
-    s2.replace(10, 12, _T("WWWW"));
-    s3.replace(1, 5, s9);
-    s4.replace(1, 4, s9, 0, 4);
-    s5.replace(1, 2, s9, 1, 12);
-    s6.replace(0, 123, s9, 0, 123);
-    s7.replace(2, 7, s9);
-
-    CPPUNIT_ASSERT( s1 == _T("QWErtyuIopopop") );
-    CPPUNIT_ASSERT( s2 == _T("QWERTYUIOPWWWW") );
-    CPPUNIT_ASSERT( s3 == _T("QwertyUIOP") );
-    CPPUNIT_ASSERT( s4 == _T("QwertYUIOP") );
-    CPPUNIT_ASSERT( s5 == _T("QertyRTYUIOP") );
-    CPPUNIT_ASSERT( s6 == s9);
-    CPPUNIT_ASSERT( s7 == _T("QWwertyP") );
-
-    // rfind
-    //       0         1         2
-    //       01234567890123456789012345
-    s1 = _T("abcdefgABCDEFGabcABCabcABC");
-    s2 = _T("gAB");
-    s3 = _T("ab");
-
-    CPPUNIT_ASSERT( s1.rfind(_T('A')) == 23u );
-    CPPUNIT_ASSERT( s1.rfind(_T('A'), 7) == 7u );
-    CPPUNIT_ASSERT( s1.rfind(_T('Z')) == wxString::npos );
-    CPPUNIT_ASSERT( s1.rfind(_T('C'), 22) == 19u );
-
-    CPPUNIT_ASSERT( s1.rfind(_T("cAB")) == 22u );
-    CPPUNIT_ASSERT( s1.rfind(_T("cAB"), 15) == wxString::npos );
-    CPPUNIT_ASSERT( s1.rfind(_T("cAB"), 21) == 16u );
-
-    CPPUNIT_ASSERT( s1.rfind(_T("gABZZZ"), 7, 3) == 6u );
-    CPPUNIT_ASSERT( s1.rfind(_T("gABZZZ"), 5, 3) == wxString::npos );
-
-    CPPUNIT_ASSERT( s1.rfind(s2) == 6u );
-    CPPUNIT_ASSERT( s1.rfind(s2, 5) == wxString::npos );
-    CPPUNIT_ASSERT( s1.rfind(s2, 6) == 6u );
-    CPPUNIT_ASSERT( s1.rfind(s3, 1) == 0u );
-
-    // resize
-    s1 = s2 = s3 = s4 = _T("abcABCdefDEF");
-
-    s1.resize( 12 );
-    s2.resize( 10 );
-    s3.resize( 14, _T(' ') );
-    s4.resize( 14, _T('W') );
-
-    CPPUNIT_ASSERT( s1 == _T("abcABCdefDEF") );
-    CPPUNIT_ASSERT( s2 == _T("abcABCdefD") );
-    CPPUNIT_ASSERT( s3 == _T("abcABCdefDEF  ") );
-    CPPUNIT_ASSERT( s4 == _T("abcABCdefDEFWW") );
-
-    // substr
-    s1 = _T("abcdefgABCDEFG");
-
-    CPPUNIT_ASSERT( s1.substr( 0, 14 ) == s1 );
-    CPPUNIT_ASSERT( s1.substr( 1, 13 ) == _T("bcdefgABCDEFG") );
-    CPPUNIT_ASSERT( s1.substr( 1, 20 ) == _T("bcdefgABCDEFG") );
-    CPPUNIT_ASSERT( s1.substr( 14, 30 ) == _T("") );
+
+void StringTestCase::CaseChanges()
+{
+    wxString s1(_T("Hello!"));
+    wxString s1u(s1);
+    wxString s1l(s1);
+    s1u.MakeUpper();
+    s1l.MakeLower();
+    wxString s2u, s2l;
+    s2u.MakeUpper();
+    s2l.MakeLower();
+
+    CPPUNIT_ASSERT( s1u == _T("HELLO!") );
+    CPPUNIT_ASSERT( s1l == _T("hello!") );
+    CPPUNIT_ASSERT( s2u == wxEmptyString );
+    CPPUNIT_ASSERT( s2l == wxEmptyString );
+
+#if !wxUSE_UNICODE
+    wxLocale locRu(wxLANGUAGE_RUSSIAN, 0 /* flags */);
+    if ( locRu.IsOk() )
+    {
+        // try upper casing 8bit strings
+        const wchar_t capital_ya[] = { 0x42f, 0 },
+                      small_ya[]   = { 0x44f, 0 };
+
+        wxString sUpper(wxConvLibc.cWC2MB(capital_ya)),
+                 sLower(wxConvLibc.cWC2MB(small_ya));
+
+        CPPUNIT_ASSERT( sUpper.Lower() == sLower );
+        CPPUNIT_ASSERT( sLower.Upper() == sUpper );
+    }
+#endif // !wxUSE_UNICODE
+}
+
+void StringTestCase::Compare()
+{
+    wxString s1 = wxT("AHH");
+    wxString eq = wxT("AHH");
+    wxString neq1 = wxT("HAH");
+    wxString neq2 = wxT("AH");
+    wxString neq3 = wxT("AHHH");
+    wxString neq4 = wxT("AhH");
+
+    CPPUNIT_ASSERT( s1 == eq );
+    CPPUNIT_ASSERT( s1 != neq1 );
+    CPPUNIT_ASSERT( s1 != neq2 );
+    CPPUNIT_ASSERT( s1 != neq3 );
+    CPPUNIT_ASSERT( s1 != neq4 );
+
+    CPPUNIT_ASSERT( s1 == wxT("AHH") );
+    CPPUNIT_ASSERT( s1 != wxT("no") );
+    CPPUNIT_ASSERT( s1 < wxT("AZ") );
+    CPPUNIT_ASSERT( s1 <= wxT("AZ") );
+    CPPUNIT_ASSERT( s1 <= wxT("AHH") );
+    CPPUNIT_ASSERT( s1 > wxT("AA") );
+    CPPUNIT_ASSERT( s1 >= wxT("AA") );
+    CPPUNIT_ASSERT( s1 >= wxT("AHH") );
+
+    // test comparison with C strings in Unicode build (must work in ANSI as
+    // well, of course):
+    CPPUNIT_ASSERT( s1 == "AHH" );
+    CPPUNIT_ASSERT( s1 != "no" );
+    CPPUNIT_ASSERT( s1 < "AZ" );
+    CPPUNIT_ASSERT( s1 <= "AZ" );
+    CPPUNIT_ASSERT( s1 <= "AHH" );
+    CPPUNIT_ASSERT( s1 > "AA" );
+    CPPUNIT_ASSERT( s1 >= "AA" );
+    CPPUNIT_ASSERT( s1 >= "AHH" );
+
+//    wxString _s1 = wxT("A\0HH");
+//    wxString _eq = wxT("A\0HH");
+//    wxString _neq1 = wxT("H\0AH");
+//    wxString _neq2 = wxT("A\0H");
+//    wxString _neq3 = wxT("A\0HHH");
+//    wxString _neq4 = wxT("A\0hH");
+    s1.insert(1,1,'\0');
+    eq.insert(1,1,'\0');
+    neq1.insert(1,1,'\0');
+    neq2.insert(1,1,'\0');
+    neq3.insert(1,1,'\0');
+    neq4.insert(1,1,'\0');
+
+    CPPUNIT_ASSERT( s1 == eq );
+    CPPUNIT_ASSERT( s1 != neq1 );
+    CPPUNIT_ASSERT( s1 != neq2 );
+    CPPUNIT_ASSERT( s1 != neq3 );
+    CPPUNIT_ASSERT( s1 != neq4 );
+}
+
+void StringTestCase::CompareNoCase()
+{
+    wxString s1 = wxT("AHH");
+    wxString eq = wxT("AHH");
+    wxString eq2 = wxT("AhH");
+    wxString eq3 = wxT("ahh");
+    wxString neq = wxT("HAH");
+    wxString neq2 = wxT("AH");
+    wxString neq3 = wxT("AHHH");
+
+    #define CPPUNIT_CNCEQ_ASSERT(s1, s2) CPPUNIT_ASSERT( s1.CmpNoCase(s2) == 0)
+    #define CPPUNIT_CNCNEQ_ASSERT(s1, s2) CPPUNIT_ASSERT( s1.CmpNoCase(s2) != 0)
+
+    CPPUNIT_CNCEQ_ASSERT( s1, eq );
+    CPPUNIT_CNCEQ_ASSERT( s1, eq2 );
+    CPPUNIT_CNCEQ_ASSERT( s1, eq3 );
+
+    CPPUNIT_CNCNEQ_ASSERT( s1, neq );
+    CPPUNIT_CNCNEQ_ASSERT( s1, neq2 );
+    CPPUNIT_CNCNEQ_ASSERT( s1, neq3 );
+
+
+//    wxString _s1 = wxT("A\0HH");
+//    wxString _eq = wxT("A\0HH");
+//    wxString _eq2 = wxT("A\0hH");
+//    wxString _eq3 = wxT("a\0hh");
+//    wxString _neq = wxT("H\0AH");
+//    wxString _neq2 = wxT("A\0H");
+//    wxString _neq3 = wxT("A\0HHH");
+
+    s1.insert(1,1,'\0');
+    eq.insert(1,1,'\0');
+    eq2.insert(1,1,'\0');
+    eq3.insert(1,1,'\0');
+    neq.insert(1,1,'\0');
+    neq2.insert(1,1,'\0');
+    neq3.insert(1,1,'\0');
+
+    CPPUNIT_CNCEQ_ASSERT( s1, eq );
+    CPPUNIT_CNCEQ_ASSERT( s1, eq2 );
+    CPPUNIT_CNCEQ_ASSERT( s1, eq3 );
+
+    CPPUNIT_CNCNEQ_ASSERT( s1, neq );
+    CPPUNIT_CNCNEQ_ASSERT( s1, neq2 );
+    CPPUNIT_CNCNEQ_ASSERT( s1, neq3 );
+}
+
+void StringTestCase::Contains()
+{
+    static const struct ContainsData
+    {
+        const wxChar *hay;
+        const wxChar *needle;
+        bool contains;
+    } containsData[] =
+    {
+        { _T(""),       _T(""),         true  },
+        { _T(""),       _T("foo"),      false },
+        { _T("foo"),    _T(""),         true  },
+        { _T("foo"),    _T("f"),        true  },
+        { _T("foo"),    _T("o"),        true  },
+        { _T("foo"),    _T("oo"),       true  },
+        { _T("foo"),    _T("ooo"),      false },
+        { _T("foo"),    _T("oooo"),     false },
+        { _T("foo"),    _T("fooo"),     false },
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(containsData); n++ )
+    {
+        const ContainsData& cd = containsData[n];
+        CPPUNIT_ASSERT_EQUAL( cd.contains, wxString(cd.hay).Contains(cd.needle) );
+    }
+}
+
+// flags used in ToLongData.flags
+enum
+{
+    Number_Ok       = 0,
+    Number_Invalid  = 1,
+    Number_Unsigned = 2,    // if not specified, works for signed conversion
+    Number_Signed   = 4,    // if not specified, works for unsigned
+    Number_LongLong = 8,    // only for long long tests
+    Number_Long     = 16,   // only for long tests
+};
+
+static const struct ToLongData
+{
+    const wxChar *str;
+#ifdef wxLongLong_t
+    wxLongLong_t value;
+#else
+    long value;
+#endif // wxLongLong_t
+    int flags;
+
+    long LValue() const { return value; }
+    unsigned long ULValue() const { return value; }
+#ifdef wxLongLong_t
+    wxLongLong_t LLValue() const { return value; }
+    wxULongLong_t ULLValue() const { return (wxULongLong_t)value; }
+#endif // wxLongLong_t
+
+    bool IsOk() const { return !(flags & Number_Invalid); }
+} longData[] =
+{
+    { _T("1"), 1, Number_Ok },
+    { _T("0"), 0, Number_Ok },
+    { _T("a"), 0, Number_Invalid },
+    { _T("12345"), 12345, Number_Ok },
+    { _T("--1"), 0, Number_Invalid },
+
+    { _T("-1"), -1, Number_Signed | Number_Long },
+    // this is surprizing but consistent with strtoul() behaviour
+    { _T("-1"), ULONG_MAX, Number_Unsigned | Number_Long },
+
+    // this must overflow, even with 64 bit long
+    { _T("922337203685477580711"), 0, Number_Invalid },
+
+#ifdef wxLongLong_t
+    { _T("2147483648"), wxLL(2147483648), Number_LongLong },
+    { _T("-2147483648"), wxLL(-2147483648), Number_LongLong | Number_Signed },
+    { _T("9223372036854775808"), wxULL(9223372036854775808), Number_LongLong |
+                                                             Number_Unsigned },
+#endif // wxLongLong_t
+};
+
+void StringTestCase::ToLong()
+{
+    long l;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+    {
+        const ToLongData& ld = longData[n];
+
+        if ( ld.flags & (Number_LongLong | Number_Unsigned) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLong(&l) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.LValue(), l );
+    }
+}
+
+void StringTestCase::ToULong()
+{
+    unsigned long ul;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+    {
+        const ToLongData& ld = longData[n];
+
+        if ( ld.flags & (Number_LongLong | Number_Signed) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULong(&ul) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.ULValue(), ul );
+    }
+}
+
+#ifdef wxLongLong_t
+
+void StringTestCase::ToLongLong()
+{
+    wxLongLong_t l;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+    {
+        const ToLongData& ld = longData[n];
+
+        if ( ld.flags & (Number_Long | Number_Unsigned) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLongLong(&l) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.LLValue(), l );
+    }
+}
+
+void StringTestCase::ToULongLong()
+{
+    wxULongLong_t ul;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )
+    {
+        const ToLongData& ld = longData[n];
+
+        if ( ld.flags & (Number_Long | Number_Signed) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULongLong(&ul) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.ULLValue(), ul );
+    }
+}
+
+#endif // wxLongLong_t
+
+void StringTestCase::ToDouble()
+{
+    double d;
+    static const struct ToDoubleData
+    {
+        const wxChar *str;
+        double value;
+        bool ok;
+    } doubleData[] =
+    {
+        { _T("1"), 1, true },
+        { _T("1.23"), 1.23, true },
+        { _T(".1"), .1, true },
+        { _T("1."), 1, true },
+        { _T("1.."), 0, false },
+        { _T("0"), 0, true },
+        { _T("a"), 0, false },
+        { _T("12345"), 12345, true },
+        { _T("-1"), -1, true },
+        { _T("--1"), 0, false },
+    };
+
+    // we need to use decimal point, not comma or whatever is its value for the
+    // current locale
+    wxSetlocale(LC_ALL, "C");
+
+    size_t n;
+    for ( n = 0; n < WXSIZEOF(doubleData); n++ )
+    {
+        const ToDoubleData& ld = doubleData[n];
+        CPPUNIT_ASSERT_EQUAL( ld.ok, wxString(ld.str).ToDouble(&d) );
+        if ( ld.ok )
+            CPPUNIT_ASSERT_EQUAL( ld.value, d );
+    }
+}
+
+void StringTestCase::WriteBuf()
+{
+    wxString s;
+    wxStrcpy(wxStringBuffer(s, 10), _T("foo"));
+
+    CPPUNIT_ASSERT(s[0u] == _T('f') );
+    CPPUNIT_ASSERT(_T('f') == s[0u]);
+    CPPUNIT_ASSERT(_T('o') == s[1]);
+    CPPUNIT_ASSERT(_T('o') == s[2]);
+    WX_ASSERT_SIZET_EQUAL(3, s.length());
+
+
+    {
+        wxStringBufferLength buf(s, 10);
+        wxStrcpy(buf, _T("barrbaz"));
+        buf.SetLength(4);
+    }
+
+    CPPUNIT_ASSERT(_T('b') == s[0u]);
+    CPPUNIT_ASSERT(_T('a') == s[1]);
+    CPPUNIT_ASSERT(_T('r') == s[2]);
+    CPPUNIT_ASSERT(_T('r') == s[3]);
+    WX_ASSERT_SIZET_EQUAL(4, s.length());
+
+    CPPUNIT_ASSERT_EQUAL( 0, wxStrcmp(_T("barr"), s) );
+}
+
+void StringTestCase::UTF8Buf()
+{
+#if wxUSE_UNICODE
+    // "czech" in Czech ("cestina"):
+    static const char *textUTF8 = "\304\215e\305\241tina";
+    static const wchar_t textUTF16[] = {0x10D, 0x65, 0x161, 0x74, 0x69, 0x6E, 0x61, 0};
+
+    wxString s;
+    wxStrcpy(wxUTF8StringBuffer(s, 9), textUTF8);
+    CPPUNIT_ASSERT(s == textUTF16);
+
+    {
+        wxUTF8StringBufferLength buf(s, 20);
+        wxStrcpy(buf, textUTF8);
+        buf.SetLength(5);
+    }
+    CPPUNIT_ASSERT(s == wxString(textUTF16, 0, 3));
+#endif // wxUSE_UNICODE
+}
+
+
+
+void StringTestCase::CStrDataTernaryOperator()
+{
+    DoCStrDataTernaryOperator(true);
+    DoCStrDataTernaryOperator(false);

 }
 
 }
 

+template<typename T> bool CheckStr(const wxString& expected, T s)
+{
+    return expected == wxString(s);
+}
+
+void StringTestCase::DoCStrDataTernaryOperator(bool cond)
+{
+    // test compilation of wxCStrData when used with operator?: (the asserts
+    // are not very important, we're testing if the code compiles at all):
+
+    wxString s("foo");
+
+    const wchar_t *wcStr = L"foo";
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : wcStr)) );
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : L"foo")) );
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? wcStr : s.c_str())) );
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? L"foo" : s.c_str())) );
+
+    const char *mbStr = "foo";
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : mbStr)) );
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? s.c_str() : "foo")) );
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? mbStr : s.c_str())) );
+    CPPUNIT_ASSERT( CheckStr(s, (cond ? "foo" : s.c_str())) );
+
+    wxString empty("");
+    CPPUNIT_ASSERT( CheckStr(empty, (cond ? empty.c_str() : wxEmptyString)) );
+    CPPUNIT_ASSERT( CheckStr(empty, (cond ? wxEmptyString : empty.c_str())) );
+}
+
+void StringTestCase::CStrDataOperators()
+{
+    wxString s("hello");
+
+    CPPUNIT_ASSERT( s.c_str()[0] == 'h' );
+    CPPUNIT_ASSERT( s.c_str()[1] == 'e' );
+    CPPUNIT_ASSERT( s.c_str()[5] == '\0' );
+
+    CPPUNIT_ASSERT( *s.c_str() == 'h' );
+    CPPUNIT_ASSERT( *(s.c_str() + 2) == 'l' );
+    CPPUNIT_ASSERT( *(s.c_str() + 5) == '\0' );
+}
+
+bool CheckStrChar(const wxString& expected, char *s)
+    { return CheckStr(expected, s); }
+bool CheckStrWChar(const wxString& expected, wchar_t *s)
+    { return CheckStr(expected, s); }
+bool CheckStrConstChar(const wxString& expected, const char *s)
+    { return CheckStr(expected, s); }
+bool CheckStrConstWChar(const wxString& expected, const wchar_t *s)
+    { return CheckStr(expected, s); }
+
+void StringTestCase::CStrDataImplicitConversion()
+{
+    wxString s("foo");
+
+    CPPUNIT_ASSERT( CheckStrConstWChar(s, s.c_str()) );
+    CPPUNIT_ASSERT( CheckStrConstChar(s, s.c_str()) );
+
+    // implicit conversion of wxString is not available in STL build
+#if !wxUSE_STL
+    CPPUNIT_ASSERT( CheckStrConstWChar(s, s) );
+    CPPUNIT_ASSERT( CheckStrConstChar(s, s) );
+#endif
+}
+
+void StringTestCase::ExplicitConversion()
+{
+    wxString s("foo");
+
+    CPPUNIT_ASSERT( CheckStr(s, s.mb_str()) );
+    CPPUNIT_ASSERT( CheckStrConstChar(s, s.mb_str()) );
+    CPPUNIT_ASSERT( CheckStrChar(s, s.char_str()) );
+
+    CPPUNIT_ASSERT( CheckStr(s, s.wc_str()) );
+    CPPUNIT_ASSERT( CheckStrConstWChar(s, s.wc_str()) );
+    CPPUNIT_ASSERT( CheckStrWChar(s, s.wchar_str()) );
+}