]> git.saurik.com Git - wxWidgets.git/blobdiff - samples/console/console.cpp
Various warning and Unicode fixes from ABX.
[wxWidgets.git] / samples / console / console.cpp
index 90178e23399329c256f93c4765760ca7bb8e8cdf..5cf447428d4b2cf413126c9a251e002b03e17a19 100644 (file)
@@ -66,6 +66,7 @@
     #define TEST_FTP
     #define TEST_HASH
     #define TEST_HASHMAP
+    #define TEST_HASHSET
     #define TEST_INFO_FUNCTIONS
     #define TEST_LIST
     #define TEST_LOCALE
@@ -78,6 +79,7 @@
     #define TEST_REGCONF
     #define TEST_REGEX
     #define TEST_REGISTRY
+    #define TEST_SCOPEGUARD
     #define TEST_SNGLINST
     #define TEST_SOCKETS
     #define TEST_STREAMS
@@ -95,7 +97,7 @@
     #undef TEST_ALL
     static const bool TEST_ALL = true;
 #else
-    #define TEST_SOCKETS
+    #define TEST_STRINGS
 
     static const bool TEST_ALL = false;
 #endif
@@ -798,6 +800,12 @@ static void TestFileConfRead()
 
         cont = fileconf.GetNextEntry(name, dummy);
     }
+
+    static const wxChar *testEntry = _T("TestEntry");
+    wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
+    fileconf.Write(testEntry, _T("A value"));
+    fileconf.DeleteEntry(testEntry);
+    wxPrintf(fileconf.HasEntry(testEntry) ? _T("ERROR\n") : _T("ok\n"));
 }
 
 #endif // TEST_FILECONF
@@ -1043,7 +1051,7 @@ static void TestFileNameMakeAbsolute()
     {
         const FileNameInfo& fni = filenames[n];
         wxFileName fn(fni.fullname, fni.format);
-        
+
         wxPrintf(_T("'%s' absolutized: "),
                fn.GetFullPath(fni.format).c_str());
         fn.MakeAbsolute();
@@ -1142,6 +1150,74 @@ static void TestHash()
 {
     wxPuts(_T("*** Testing wxHashTable ***\n"));
 
+    {
+        wxHashTable hash(wxKEY_INTEGER, 10), hash2(wxKEY_STRING);
+        wxObject o;
+        int i;
+
+        for ( i = 0; i < 100; ++i )
+            hash.Put(i, &o + i);
+
+        hash.BeginFind();
+        wxHashTable::compatibility_iterator it = hash.Next();
+        i = 0;
+
+        while (it)
+        {
+            ++i;
+            it = hash.Next();
+        }
+
+        if (i != 100)
+            wxPuts(_T("Error in wxHashTable::compatibility_iterator\n"));
+
+        for ( i = 99; i >= 0; --i )
+            if( hash.Get(i) != &o + i )
+                wxPuts(_T("Error in wxHashTable::Get/Put\n"));
+
+        for ( i = 0; i < 100; ++i )
+            hash.Put(i, &o + i + 20);
+
+        for ( i = 99; i >= 0; --i )
+            if( hash.Get(i) != &o + i)
+                wxPuts(_T("Error (2) in wxHashTable::Get/Put\n"));
+
+        for ( i = 0; i < 50; ++i )
+            if( hash.Delete(i) != &o + i)
+                wxPuts(_T("Error in wxHashTable::Delete\n"));
+
+        for ( i = 50; i < 100; ++i )
+            if( hash.Get(i) != &o + i)
+                wxPuts(_T("Error (3) in wxHashTable::Get/Put\n"));
+
+        for ( i = 0; i < 50; ++i )
+            if( hash.Get(i) != &o + i + 20)
+                wxPuts(_T("Error (4) in wxHashTable::Put/Delete\n"));
+
+        for ( i = 0; i < 50; ++i )
+            if( hash.Delete(i) != &o + i + 20)
+                wxPuts(_T("Error (2) in wxHashTable::Delete\n"));
+
+        for ( i = 0; i < 50; ++i )
+            if( hash.Get(i) != NULL)
+                wxPuts(_T("Error (5) in wxHashTable::Put/Delete\n"));
+
+        hash2.Put(_T("foo"), &o + 1);
+        hash2.Put(_T("bar"), &o + 2);
+        hash2.Put(_T("baz"), &o + 3);
+
+        if (hash2.Get(_T("moo")) != NULL)
+            wxPuts(_T("Error in wxHashTable::Get\n"));
+
+        if (hash2.Get(_T("bar")) != &o + 2)
+            wxPuts(_T("Error in wxHashTable::Get/Put\n"));
+
+        hash2.Put(_T("bar"), &o + 0);
+
+        if (hash2.Get(_T("bar")) != &o + 2)
+            wxPuts(_T("Error (2) in wxHashTable::Get/Put\n"));
+    }
+#if !wxUSE_STL
     {
         wxHashFoos hash;
         hash.DeleteContents(true);
@@ -1191,8 +1267,10 @@ static void TestHash()
             wxPuts(_T("ok (not found)"));
         }
     }
+#endif
 
     wxPrintf(_T("Hash destroyed: %u foos left\n"), Foo::count);
+    wxPuts(_T("*** Testing wxHashTable finished ***\n"));
 }
 
 #endif // TEST_HASH
@@ -1343,6 +1421,100 @@ static void TestHashMap()
 
 #endif // TEST_HASHMAP
 
+// ----------------------------------------------------------------------------
+// wxHashSet
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_HASHSET
+
+#include "wx/hashset.h"
+
+// test compilation of basic map types
+WX_DECLARE_HASH_SET( int*, wxPointerHash, wxPointerEqual, myPtrHashSet );
+WX_DECLARE_HASH_SET( long, wxIntegerHash, wxIntegerEqual, myLongHashSet );
+WX_DECLARE_HASH_SET( unsigned long, wxIntegerHash, wxIntegerEqual,
+                     myUnsignedHashSet );
+WX_DECLARE_HASH_SET( unsigned int, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet1 );
+WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet2 );
+WX_DECLARE_HASH_SET( short, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet3 );
+WX_DECLARE_HASH_SET( unsigned short, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet4 );
+WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual,
+                     myTestHashSet5 );
+
+struct MyStruct
+{
+    int* ptr;
+    wxString str;
+};
+
+class MyHash
+{
+public:
+    unsigned long operator()(const MyStruct& s) const
+        { return m_dummy(s.ptr); }
+    MyHash& operator=(const MyHash&) { return *this; }
+private:
+    wxPointerHash m_dummy;
+};
+
+class MyEqual
+{
+public:
+    bool operator()(const MyStruct& s1, const MyStruct& s2) const
+        { return s1.ptr == s2.ptr; }
+    MyEqual& operator=(const MyEqual&) { return *this; }
+};
+
+WX_DECLARE_HASH_SET( MyStruct, MyHash, MyEqual, mySet );
+
+typedef myTestHashSet5 wxStringHashSet;
+
+static void TestHashSet()
+{
+    wxPrintf(_T("*** Testing wxHashSet ***\n"));
+
+    wxStringHashSet set1;
+
+    set1.insert( _T("abc") );
+    set1.insert( _T("bbc") );
+    set1.insert( _T("cbc") );
+    set1.insert( _T("abc") );
+
+    if( set1.size() != 3 )
+        wxPrintf(_T("*** ERROR IN INSERT ***\n"));
+
+    mySet set2;
+    int dummy;
+    MyStruct tmp;
+
+    tmp.ptr = &dummy; tmp.str = _T("ABC");
+    set2.insert( tmp );
+    tmp.ptr = &dummy + 1;
+    set2.insert( tmp );
+    tmp.ptr = &dummy; tmp.str = _T("CDE");
+    set2.insert( tmp );
+
+    if( set2.size() != 2 )
+        wxPrintf(_T("*** ERROR IN INSERT - 2 ***\n"));
+
+    mySet::iterator it = set2.find( tmp );
+
+    if( it == set2.end() )
+        wxPrintf(_T("*** ERROR IN FIND - 1 ***\n"));
+    if( it->ptr != &dummy )
+        wxPrintf(_T("*** ERROR IN FIND - 2 ***\n"));
+    if( it->str != _T("ABC") )
+        wxPrintf(_T("*** ERROR IN INSERT - 3 ***\n"));
+
+    wxPrintf(_T("*** Finished testing wxHashSet ***\n"));
+}
+
+#endif // TEST_HASHSET
+
 // ----------------------------------------------------------------------------
 // wxList
 // ----------------------------------------------------------------------------
@@ -1355,6 +1527,104 @@ WX_DECLARE_LIST(Bar, wxListBars);
 #include "wx/listimpl.cpp"
 WX_DEFINE_LIST(wxListBars);
 
+WX_DECLARE_LIST(int, wxListInt);
+WX_DEFINE_LIST(wxListInt);
+
+static void TestList()
+{
+    wxPuts(_T("*** Testing wxList operations ***\n"));
+    {
+        wxListInt list1;
+        int dummy[5];
+        int i;
+
+        for ( i = 0; i < 5; ++i )
+            list1.Append(dummy + i);
+
+        if ( list1.GetCount() != 5 )
+            wxPuts(_T("Wrong number of items in list\n"));
+
+        if ( list1.Item(3)->GetData() != dummy + 3 )
+            wxPuts(_T("Error in Item()\n"));
+
+        if ( !list1.Find(dummy + 4) )
+            wxPuts(_T("Error in Find()\n"));
+
+        wxListInt::compatibility_iterator node = list1.GetFirst();
+        i = 0;
+
+        while (node)
+        {
+            if ( node->GetData() != dummy + i )
+                wxPuts(_T("Error in compatibility_iterator\n"));
+            node = node->GetNext();
+            ++i;
+        }
+
+        if ( size_t(i) != list1.GetCount() )
+            wxPuts(_T("Error in compatibility_iterator\n"));
+
+        list1.Insert(dummy + 0);
+        list1.Insert(1, dummy + 1);
+        list1.Insert(list1.GetFirst()->GetNext()->GetNext(), dummy + 2);
+
+        node = list1.GetFirst();
+        i = 0;
+
+        while (i < 3)
+        {
+            int* t = node->GetData();
+            if ( t != dummy + i )
+                wxPuts(_T("Error in Insert\n"));
+            node = node->GetNext();
+            ++i;
+        }
+    }
+
+    wxPuts(_T("*** Testing wxList operations finished ***\n"));
+
+    wxPuts(_T("*** Testing std::list operations ***\n"));
+
+    {
+        wxListInt list1;
+        wxListInt::iterator it, en;
+        wxListInt::reverse_iterator rit, ren;
+        int i;
+        for ( i = 0; i < 5; ++i )
+            list1.push_back(i + &i);
+
+        for ( it = list1.begin(), en = list1.end(), i = 0;
+              it != en; ++it, ++i )
+            if ( *it != i + &i )
+                wxPuts(_T("Error in iterator\n"));
+
+        for ( rit = list1.rbegin(), ren = list1.rend(), i = 4;
+              rit != ren; ++rit, --i )
+            if ( *rit != i + &i )
+                wxPuts(_T("Error in reverse_iterator\n"));
+
+        if ( *list1.rbegin() != *--list1.end() ||
+             *list1.begin() != *--list1.rend() )
+            wxPuts(_T("Error in iterator/reverse_iterator\n"));
+        if ( *list1.begin() != *--++list1.begin() ||
+             *list1.rbegin() != *--++list1.rbegin() )
+            wxPuts(_T("Error in iterator/reverse_iterator\n"));
+
+        if ( list1.front() != &i || list1.back() != &i + 4 )
+            wxPuts(_T("Error in front()/back()\n"));
+
+        list1.erase(list1.begin());
+        list1.erase(--list1.end());
+
+        for ( it = list1.begin(), en = list1.end(), i = 1;
+              it != en; ++it, ++i )
+            if ( *it != i + &i )
+                wxPuts(_T("Error in erase()\n"));
+    }
+    
+    wxPuts(_T("*** Testing std::list operations finished ***\n"));
+}
+
 static void TestListCtor()
 {
     wxPuts(_T("*** Testing wxList construction ***\n"));
@@ -1373,7 +1643,11 @@ static void TestListCtor()
         wxPrintf(_T("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n"),
                list1.GetCount(), list2.GetCount(), Bar::GetNumber());
 
+#if !wxUSE_STL
         list1.DeleteContents(true);
+#else
+        WX_CLEAR_LIST(wxListBars, list1);
+#endif
     }
 
     wxPrintf(_T("After list destruction: %u objects left.\n"), Bar::GetNumber());
@@ -2979,6 +3253,42 @@ static void TestRegistryAssociation()
 
 #endif // TEST_REGISTRY
 
+// ----------------------------------------------------------------------------
+// scope guard
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_SCOPEGUARD
+
+#include "wx/scopeguard.h"
+
+static void function0() { puts("function0()"); }
+static void function1(int n) { printf("function1(%d)\n", n); }
+static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
+
+struct Object
+{
+    void method0() { printf("method0()\n"); }
+    void method1(int n) { printf("method1(%d)\n", n); }
+    void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
+};
+
+static void TestScopeGuard()
+{
+    ON_BLOCK_EXIT0(function0);
+    ON_BLOCK_EXIT1(function1, 17);
+    ON_BLOCK_EXIT2(function2, 3.14, 'p');
+
+    Object obj;
+    ON_BLOCK_EXIT_OBJ0(obj, &Object::method0);
+    ON_BLOCK_EXIT_OBJ1(obj, &Object::method1, 7);
+    ON_BLOCK_EXIT_OBJ2(obj, &Object::method2, 2.71, 'e');
+
+    wxScopeGuard dismissed = wxMakeGuard(function0);
+    dismissed.Dismiss();
+}
+
+#endif
+
 // ----------------------------------------------------------------------------
 // sockets
 // ----------------------------------------------------------------------------
@@ -4156,7 +4466,6 @@ static void TestZlibStreamRead()
 
 #include <math.h>
 
-#include "wx/date.h"
 #include "wx/datetime.h"
 
 // the test data
@@ -5156,38 +5465,6 @@ static void TestTimeSpanFormat()
     wxPuts(_T(""));
 }
 
-#if 0
-
-// test compatibility with the old wxDate/wxTime classes
-static void TestTimeCompatibility()
-{
-    wxPuts(_T("\n*** wxDateTime compatibility test ***"));
-
-    wxPrintf(_T("wxDate for JDN 0: %s\n"), wxDate(0l).FormatDate().c_str());
-    wxPrintf(_T("wxDate for MJD 0: %s\n"), wxDate(2400000).FormatDate().c_str());
-
-    double jdnNow = wxDateTime::Now().GetJDN();
-    long jdnMidnight = (long)(jdnNow - 0.5);
-    wxPrintf(_T("wxDate for today: %s\n"), wxDate(jdnMidnight).FormatDate().c_str());
-
-    jdnMidnight = wxDate().Set().GetJulianDate();
-    wxPrintf(_T("wxDateTime for today: %s\n"),
-            wxDateTime((double)(jdnMidnight + 0.5)).Format("%c", wxDateTime::GMT0).c_str());
-
-    int flags = wxEUROPEAN;//wxFULL;
-    wxDate date;
-    date.Set();
-    wxPrintf(_T("Today is %s\n"), date.FormatDate(flags).c_str());
-    for ( int n = 0; n < 7; n++ )
-    {
-        wxPrintf(_T("Previous %s is %s\n"),
-               wxDateTime::GetWeekDayName((wxDateTime::WeekDay)n),
-               date.Previous(n + 1).FormatDate(flags).c_str());
-    }
-}
-
-#endif // 0
-
 #endif // TEST_DATETIME
 
 // ----------------------------------------------------------------------------
@@ -5710,6 +5987,17 @@ static void PrintArray(const wxChar* name, const wxArrayString& array)
     }
 }
 
+static void PrintArray(const wxChar* name, const wxSortedArrayString& array)
+{
+    wxPrintf(_T("Dump of the array '%s'\n"), name);
+
+    size_t nCount = array.GetCount();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        wxPrintf(_T("\t%s[%u] = '%s'\n"), name, n, array[n].c_str());
+    }
+}
+
 int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
                                     const wxString& second)
 {
@@ -5774,6 +6062,53 @@ static void TestArrayOf ## name ## s()                                        \
 TestArrayOf(UShort);
 TestArrayOf(Int);
 
+static void TestStlArray()
+{
+    wxPuts(_T("*** Testing std::vector operations ***\n"));
+
+    {
+        wxArrayInt list1;
+        wxArrayInt::iterator it, en;
+        wxArrayInt::reverse_iterator rit, ren;
+        int i;
+        for ( i = 0; i < 5; ++i )
+            list1.push_back(i);
+
+        for ( it = list1.begin(), en = list1.end(), i = 0;
+              it != en; ++it, ++i )
+            if ( *it != i )
+                wxPuts(_T("Error in iterator\n"));
+
+        for ( rit = list1.rbegin(), ren = list1.rend(), i = 4;
+              rit != ren; ++rit, --i )
+            if ( *rit != i )
+                wxPuts(_T("Error in reverse_iterator\n"));
+
+        if ( *list1.rbegin() != *(list1.end()-1) ||
+             *list1.begin() != *(list1.rend()-1) )
+            wxPuts(_T("Error in iterator/reverse_iterator\n"));
+
+        it = list1.begin()+1;
+        rit = list1.rbegin()+1;
+        if ( *list1.begin() != *(it-1) ||
+             *list1.rbegin() != *(rit-1) )
+            wxPuts(_T("Error in iterator/reverse_iterator\n"));
+
+        if ( list1.front() != 0 || list1.back() != 4 )
+            wxPuts(_T("Error in front()/back()\n"));
+
+        list1.erase(list1.begin());
+        list1.erase(list1.end()-1);
+
+        for ( it = list1.begin(), en = list1.end(), i = 1;
+              it != en; ++it, ++i )
+            if ( *it != i )
+                wxPuts(_T("Error in erase()\n"));
+    }
+    
+    wxPuts(_T("*** Testing std::vector operations finished ***\n"));
+}
+
 static void TestArrayOfObjects()
 {
     wxPuts(_T("*** Testing wxObjArray ***\n"));
@@ -5861,14 +6196,14 @@ static void TestString()
 
     for (int i = 0; i < 1000000; ++i)
     {
-        a = "Hello";
-        b = " world";
-        c = "! How'ya doin'?";
+        a = _T("Hello");
+        b = _T(" world");
+        c = _T("! How'ya doin'?");
         a += b;
         a += c;
-        c = "Hello world! What's up?";
+        c = _T("Hello world! What's up?");
         if (c != a)
-            c = "Doh!";
+            c = _T("Doh!");
     }
 
     wxPrintf(_T("TestString elapsed time: %ld\n"), sw.Time());
@@ -5899,7 +6234,7 @@ static void TestPChar()
 
 static void TestStringSub()
 {
-    wxString s("Hello, world!");
+    wxString s(_T("Hello, world!"));
 
     wxPuts(_T("*** Testing wxString substring extraction ***"));
 
@@ -6196,6 +6531,325 @@ static void TestStringMatch()
     wxPuts(_T(""));
 }
 
+// Sigh, I want Test::Simple, Test::More and Test::Harness...
+void ok(int line, bool ok, const wxString& msg = wxEmptyString)
+{
+    if( !ok )
+        wxPuts(_T("NOT OK: (") + wxString::Format(_T("%d"), line) +
+               _T(") ") + msg);
+}
+
+void is(int line, const wxString& got, const wxString& expected,
+        const wxString& msg = wxEmptyString)
+{
+    bool isOk = got == expected;
+    ok(line, isOk, msg);
+    if( !isOk )
+    {
+        wxPuts(_T("Got: ") + got);
+        wxPuts(_T("Expected: ") + expected);
+    }
+}
+
+#if 0
+void is(int line, const wxChar* got, const wxChar* expected,
+        const wxString& msg = wxEmptyString)
+{
+    bool isOk = wxStrcmp( got, expected ) == 0;
+    ok(line, isOk, msg);
+    if( !isOk )
+    {
+        wxPuts(_T("Got: ") + wxString(got));
+        wxPuts(_T("Expected: ") + wxString(expected));
+    }
+}
+#endif
+
+void is(int line, const wxChar& got, const wxChar& expected,
+        const wxString& msg = wxEmptyString)
+{
+    bool isOk = got == expected;
+    ok(line, isOk, msg);
+    if( !isOk )
+    {
+        wxPuts(_T("Got: ") + got);
+        wxPuts(_T("Expected: ") + expected);
+    }
+}
+
+void is(int line, size_t got, size_t expected,
+        const wxString& msg = wxEmptyString)
+{
+    bool isOk = got == expected;
+    ok(line, isOk, msg);
+    if( !isOk )
+    {
+        wxPuts(wxString::Format(_T("Got: %ld"), got));
+        wxPuts(wxString::Format(_T("Expected: %ld"), expected));
+    }
+}
+
+#define is_m( got, expected, message ) is( __LINE__, (got), (expected), (message) )
+#define is_nom( got, expected ) is( __LINE__, (got), (expected), wxEmptyString )
+
+void TestStdString()
+{
+    wxPuts(_T("*** Testing std::string operations ***\n"));
+
+    // test ctors
+    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;
+
+    is( __LINE__, s1, _T("abcdefgh") );
+    is( __LINE__, s2, s1 );
+    is( __LINE__, s4, _T("aaaaaaaa") );
+    is( __LINE__, s5, _T("abcdefgh") );
+    is( __LINE__, s6, s1 );
+    is( __LINE__, s7, s1 );
+    is( __LINE__, 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());
+
+    is( __LINE__, s1, _T("abcdef") );
+    is( __LINE__, s2, _T("abcdef") );
+    is( __LINE__, s3, _T("abcdef") );
+    is( __LINE__, s4, _T("abcabcdef") );
+    is( __LINE__, s5, _T("abcaaa") );
+    is( __LINE__, 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());
+
+    is( __LINE__, s1, _T("def") );
+    is( __LINE__, s2, _T("def") );
+    is( __LINE__, s3, _T("def") );
+    is( __LINE__, s4, _T("def") );
+    is( __LINE__, s5, _T("aaa") );
+    is( __LINE__, 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");
+
+    ok( __LINE__, s1.compare(s2) == 0 );
+    ok( __LINE__, s1.compare(s3) > 0 );
+    ok( __LINE__, s1.compare(s4) < 0 );
+    ok( __LINE__, s1.compare(s5) > 0 );
+    ok( __LINE__, s1.compare(s6) < 0 );
+    ok( __LINE__, s1.compare(1, 12, s1) > 0);
+    ok( __LINE__, s1.compare(_T("abcdefgh")) == 0);
+    ok( __LINE__, s1.compare(1, 7, _T("bcdefgh")) == 0);
+    ok( __LINE__, 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);
+
+    is( __LINE__, s1, _T("acdefgh") );
+    is( __LINE__, s2, _T("abcd") );
+    is( __LINE__, s3, _T("ac") );
+    is( __LINE__, s4, _T("abcdghi") );
+    is( __LINE__, s7, _T("zabc") );
+    is( __LINE__, *it, _T('c') );
+    is( __LINE__, *it2, _T('g') );
+    ok( __LINE__, it3 == s7.end() );
+
+    // find
+    //       0         1         2
+    //       01234567890123456789012345
+    s1 = _T("abcdefgABCDEFGabcABCabcABC");
+    s2 = _T("gAB");
+
+    is_nom( s1.find(_T('A')), 7u );
+    is_nom( s1.find(_T('A'), 7), 7u );
+    is_nom( s1.find(_T('Z')), wxString::npos );
+    is_nom( s1.find(_T('C'), 22), 25u );
+
+    is_nom( s1.find(_T("gAB")), 6u );
+    is_nom( s1.find(_T("gAB"), 7), wxString::npos );
+    is_nom( s1.find(_T("gAB"), 6), 6u );
+
+    is_nom( s1.find(_T("gABZZZ"), 2, 3), 6u );
+    is_nom( s1.find(_T("gABZZZ"), 7, 3), wxString::npos );
+
+    is_nom( s1.find(s2), 6u );
+    is_nom( s1.find(s2, 7), wxString::npos );
+    is_nom( s1.find(s2, 6), 6u );
+
+    // find_first_not_of
+    //       0         1         2         3
+    //       01234567890123456789012345678901234
+    s1 = _T("aaaaaabcdefghlkjiaaaaaabcdbcdbcdbcd");
+    s2 = _T("aaaaaa");
+
+    is_nom( s1.find_first_not_of(_T('a')), 6u );
+    is_nom( s1.find_first_not_of(_T('a'), 7), 7u );
+    is_nom( s2.find_first_not_of(_T('a')), wxString::npos );
+
+    is_nom( s1.find_first_not_of(_T("abde"), 4), 7u );
+    is_nom( s1.find_first_not_of(_T("abde"), 7), 7u );
+    is_nom( s1.find_first_not_of(_T("abcdefghijkl")), wxString::npos );
+
+    is_nom( s1.find_first_not_of(_T("abcdefghi"), 0, 4), 9u );
+
+    // find_first_of
+    is_nom( s1.find_first_of(_T('c')), 7u );
+    is_nom( s1.find_first_of(_T('v')), wxString::npos );
+    is_nom( s1.find_first_of(_T('c'), 10), 24u );
+
+    is_nom( s1.find_first_of(_T("ijkl")), 13u );
+    is_nom( s1.find_first_of(_T("ddcfg"), 17), 24u );
+    is_nom( s1.find_first_of(_T("ddcfga"), 17, 5), 24u );
+
+    // find_last_not_of
+    //       0         1         2         3
+    //       01234567890123456789012345678901234
+    s1 = _T("aaaaaabcdefghlkjiaaaaaabcdbcdbcdbcd");
+    s2 = _T("aaaaaa");
+
+    is_nom( s2.find_last_not_of(_T('a')), wxString::npos );
+    is_nom( s1.find_last_not_of(_T('d')), 33u );
+    is_nom( s1.find_last_not_of(_T('d'), 25), 24u );
+
+    is_nom( s1.find_last_not_of(_T("bcd")), 22u );
+    is_nom( s1.find_last_not_of(_T("abc"), 24), 16u );
+
+    is_nom( s1.find_last_not_of(_T("abcdefghijklmnopqrstuv"), 24, 3), 16u );
+
+    // find_last_of
+    is_nom( s2.find_last_of(_T('c')), wxString::npos );
+    is_nom( s1.find_last_of(_T('a')), 22u );
+    is_nom( s1.find_last_of(_T('b'), 24), 23u );
+
+    is_nom( s1.find_last_of(_T("ijklm")), 16u );
+    is_nom( s1.find_last_of(_T("ijklma"), 33, 4), 16u );
+    is_nom( 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'));
+
+    is( __LINE__, s1, _T("accaaa") );
+    is( __LINE__, s2, _T("aacdeaa") );
+    is( __LINE__, s3, _T("aacdefgaa") );
+    is( __LINE__, s4, _T("aafgaa") );
+    is( __LINE__, s5, _T("accaaa") );
+    is( __LINE__, s6, _T("aaaXa") );
+    is( __LINE__, s7, _T("cdefaaaa") );
+    is( __LINE__, s8, _T("ccaaaa") );
+
+    s1 = s2 = s3 = _T("aaaa");
+    s1.insert(0, _T("ccc"), 2);
+    s2.insert(4, _T("ccc"), 2);
+
+    is( __LINE__, s1, _T("ccaaaa") );
+    is( __LINE__, 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);
+
+    is( __LINE__, s1, _T("QWErtyuIopopop") );
+    is( __LINE__, s2, _T("QWERTYUIOPWWWW") );
+    is( __LINE__, s3, _T("QwertyUIOP") );
+    is( __LINE__, s4, _T("QwertYUIOP") );
+    is( __LINE__, s5, _T("QertyRTYUIOP") );
+    is( __LINE__, s6, s9);
+    is( __LINE__, s7, _T("QWwertyP") );
+
+    // rfind
+    //       0         1         2
+    //       01234567890123456789012345
+    s1 = _T("abcdefgABCDEFGabcABCabcABC");
+    s2 = _T("gAB");
+    s3 = _T("ab");
+
+    is_nom( s1.rfind(_T('A')), 23u );
+    is_nom( s1.rfind(_T('A'), 7), 7u );
+    is_nom( s1.rfind(_T('Z')), wxString::npos );
+    is_nom( s1.rfind(_T('C'), 22), 19u );
+
+    is_nom( s1.rfind(_T("cAB")), 22u );
+    is_nom( s1.rfind(_T("cAB"), 15), wxString::npos );
+    is_nom( s1.rfind(_T("cAB"), 21), 16u );
+
+    is_nom( s1.rfind(_T("gABZZZ"), 7, 3), 6u );
+    is_nom( s1.rfind(_T("gABZZZ"), 5, 3), wxString::npos );
+
+    is_nom( s1.rfind(s2), 6u );
+    is_nom( s1.rfind(s2, 5), wxString::npos );
+    is_nom( s1.rfind(s2, 6), 6u );
+    is_nom( 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') );
+
+    is_nom( s1, _T("abcABCdefDEF") );
+    is_nom( s2, _T("abcABCdefD") );
+    is_nom( s3, _T("abcABCdefDEF  ") );
+    is_nom( s4, _T("abcABCdefDEFWW") );
+
+    // substr
+    s1 = _T("abcdefgABCDEFG");
+
+    is_nom( s1.substr( 0, 14 ), s1 );
+    is_nom( s1.substr( 1, 13 ), _T("bcdefgABCDEFG") );
+    is_nom( s1.substr( 1, 20 ), _T("bcdefgABCDEFG") );
+    is_nom( s1.substr( 14, 30 ), _T("") );
+
+    wxPuts(_T("*** Testing std::string operations finished ***\n"));
+}
+
 #endif // TEST_STRINGS
 
 // ----------------------------------------------------------------------------
@@ -6208,7 +6862,7 @@ static void TestStringMatch()
 
 int main(int argc, char **argv)
 {
-    wxApp::CheckBuildOptions(wxBuildOptions());
+    wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
 
     wxInitializer initializer;
     if ( !initializer )
@@ -6332,10 +6986,12 @@ int main(int argc, char **argv)
     {
         TestStringMatch();
     }
+
+    TestStdString();
 #endif // TEST_STRINGS
 
 #ifdef TEST_ARRAYS
-    if ( TEST_ALL )
+    if ( 1 || TEST_ALL )
     {
         wxArrayString a1;
         a1.Add(_T("tiger"));
@@ -6352,38 +7008,50 @@ int main(int argc, char **argv)
         wxArrayString a2(a1);
         PrintArray(_T("a2"), a2);
 
+#if !wxUSE_STL
         wxSortedArrayString a3(a1);
+#else
+        wxSortedArrayString a3;
+        for (wxArrayString::iterator it = a1.begin(), en = a1.end();
+             it != en; ++it)
+            a3.Add(*it);
+#endif
         PrintArray(_T("a3"), a3);
 
         wxPuts(_T("*** After deleting three strings from a1"));
-        a1.Remove(2,3);
+        a1.RemoveAt(2,3);
 
         PrintArray(_T("a1"), a1);
         PrintArray(_T("a2"), a2);
         PrintArray(_T("a3"), a3);
 
+#if !wxUSE_STL
         wxPuts(_T("*** After reassigning a1 to a2 and a3"));
         a3 = a2 = a1;
         PrintArray(_T("a2"), a2);
         PrintArray(_T("a3"), a3);
+#endif
 
         wxPuts(_T("*** After sorting a1"));
-        a1.Sort();
+        a1.Sort(wxStringCompareAscending);
         PrintArray(_T("a1"), a1);
 
         wxPuts(_T("*** After sorting a1 in reverse order"));
-        a1.Sort(true);
+        a1.Sort(wxStringCompareDescending);
         PrintArray(_T("a1"), a1);
 
+#if !wxUSE_STL
         wxPuts(_T("*** After sorting a1 by the string length"));
-        a1.Sort(StringLenCompare);
+        a1.Sort(&StringLenCompare);
         PrintArray(_T("a1"), a1);
+#endif
 
         TestArrayOfObjects();
         TestArrayOfUShorts();
     }
 
     TestArrayOfInts();
+    TestStlArray();
 #endif // TEST_ARRAYS
 
 #ifdef TEST_DIR
@@ -6413,6 +7081,7 @@ int main(int argc, char **argv)
 
 #ifdef TEST_LIST
     TestListCtor();
+    TestList();
 #endif // TEST_LIST
 
 #ifdef TEST_LOCALE
@@ -6534,6 +7203,10 @@ int main(int argc, char **argv)
     TestHashMap();
 #endif // TEST_HASHMAP
 
+#ifdef TEST_HASHSET
+    TestHashSet();
+#endif // TEST_HASHSET
+
 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));
     if ( TEST_ALL )
@@ -6658,6 +7331,10 @@ int main(int argc, char **argv)
         TestDateTimeInteractive();
 #endif // TEST_DATETIME
 
+#ifdef TEST_SCOPEGUARD
+    TestScopeGuard();
+#endif
+
 #ifdef TEST_USLEEP
     wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
     wxUsleep(3000);