]> git.saurik.com Git - wxWidgets.git/blobdiff - samples/console/console.cpp
Added python support for a virtual CanDismiss method
[wxWidgets.git] / samples / console / console.cpp
index 3caad396af5ce301fc0ab9c2b98bdd5cf3b5fa8c..b0062a69cc6f0090ca4d90a5d9d344db98ade9fc 100644 (file)
@@ -48,7 +48,7 @@
  */
 
 // what to test (in alphabetic order)? uncomment the line below to do all tests
-#define TEST_ALL
+// #define TEST_ALL
 #ifdef TEST_ALL
     #define TEST_ARRAYS
     #define TEST_CHARSET
@@ -64,6 +64,7 @@
     #define TEST_FILETIME
     #define TEST_FTP
     #define TEST_HASH
+    #define TEST_HASHMAP
     #define TEST_INFO_FUNCTIONS
     #define TEST_LIST
     #define TEST_LOCALE
@@ -71,6 +72,7 @@
     #define TEST_LONGLONG
     #define TEST_MIME
     #define TEST_PATHLIST
+    #define TEST_ODBC
     #define TEST_REGCONF
     #define TEST_REGEX
     #define TEST_REGISTRY
@@ -88,7 +90,7 @@
     #undef TEST_ALL
     static const bool TEST_ALL = TRUE;
 #else
-    #define TEST_FILENAME
+    #define TEST_ARRAYS
 
     static const bool TEST_ALL = FALSE;
 #endif
@@ -97,7 +99,7 @@
 #ifdef TEST_INTERACTIVE
     #undef TEST_INTERACTIVE
 
-    static const bool TEST_INTERACTIVE = FALSE;
+    static const bool TEST_INTERACTIVE = TRUE;
 #else
     static const bool TEST_INTERACTIVE = FALSE;
 #endif
@@ -828,7 +830,7 @@ static void TestFileNameConstruction()
             printf("ERROR: fullname should be '%s'\n", fni.fullname);
         }
 
-        bool isAbsolute = fn.IsAbsolute(fni.format);
+        bool isAbsolute = fn.IsAbsolute();
         printf("'%s' is %s (%s)\n\t",
                fullname.c_str(),
                isAbsolute ? "absolute" : "relative",
@@ -1094,6 +1096,152 @@ static void TestHash()
 
 #endif // TEST_HASH
 
+// ----------------------------------------------------------------------------
+// wxHashMap
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_HASHMAP
+
+#include "wx/hashmap.h"
+
+// test compilation of basic map types
+WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash, wxPointerEqual, myPtrHashMap );
+WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
+WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
+                     myUnsignedHashMap );
+WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
+                     myTestHashMap1 );
+WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
+                     myTestHashMap2 );
+WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
+                     myTestHashMap3 );
+WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
+                     myTestHashMap4 );
+
+// same as:
+// WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
+//                      myStringHashMap );
+WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
+
+typedef myStringHashMap::iterator Itor;
+
+static void TestHashMap()
+{
+    puts("*** Testing wxHashMap ***\n");
+    myStringHashMap sh(0); // as small as possible
+    wxString buf;
+    size_t i;
+    const size_t count = 10000;
+
+    // init with some data
+    for( i = 0; i < count; ++i )
+    {
+        buf.Printf(wxT("%d"), i );
+        sh[buf] = wxT("A") + buf + wxT("C");
+    }
+
+    // test that insertion worked
+    if( sh.size() != count )
+    {
+        printf("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n", sh.size(), count);
+    }
+
+    for( i = 0; i < count; ++i )
+    {
+        buf.Printf(wxT("%d"), i );
+        if( sh[buf] != wxT("A") + buf + wxT("C") )
+        {
+            printf("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n");
+            return;
+        }
+    }
+
+    // check that iterators work
+    Itor it;
+    for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
+    {
+        if( i == count )
+        {
+            printf("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n");
+            return;
+        }
+
+        if( it->second != sh[it->first] )
+        {
+            printf("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n");
+            return;
+        }
+    }
+
+    if( sh.size() != i )
+    {
+        printf("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n", i, count);
+    }
+
+    // test copy ctor, assignment operator
+    myStringHashMap h1( sh ), h2( 0 );
+    h2 = sh;
+
+    for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
+    {
+        if( h1[it->first] != it->second )
+        {
+            printf("*** ERROR: COPY CTOR BROKEN %s ***\n", it->first.c_str());
+        }
+
+        if( h2[it->first] != it->second )
+        {
+            printf("*** ERROR: OPERATOR= BROKEN %s ***\n", it->first.c_str());
+        }
+    }
+
+    // other tests
+    for( i = 0; i < count; ++i )
+    {
+        buf.Printf(wxT("%d"), i );
+        size_t sz = sh.size();
+
+        // test find() and erase(it)
+        if( i < 100 )
+        {
+            it = sh.find( buf );
+            if( it != sh.end() )
+            {
+                sh.erase( it );
+
+                if( sh.find( buf ) != sh.end() )
+                {
+                    printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i);
+                }
+            }
+            else
+                printf("*** ERROR: CANT FIND ELEMENT %u ***\n", i);
+        }
+        else
+        // test erase(key)
+        {
+            size_t c = sh.erase( buf );
+            if( c != 1 )
+                printf("*** ERROR: SHOULD RETURN 1 ***\n");
+
+            if( sh.find( buf ) != sh.end() )
+            {
+                printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i);
+            }
+        }
+
+        // count should decrease
+        if( sh.size() != sz - 1 )
+        {
+            printf("*** ERROR: COUNT DID NOT DECREASE ***\n");
+        }
+    }
+
+    printf("*** Finished testing wxHashMap ***\n");
+}
+
+#endif // TEST_HASHMAP
+
 // ----------------------------------------------------------------------------
 // wxList
 // ----------------------------------------------------------------------------
@@ -1799,8 +1947,15 @@ static void TestDivision()
         // multiplication will not overflow)
         wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
 
-        // get a random long (not wxLongLong for now) to divide it with
-        long l = rand();
+        // get a random (but non null) long (not wxLongLong for now) to divide
+        // it with
+        long l;
+        do
+        {
+           l = rand();
+        }
+        while ( !l );
+
         q = ll / l;
         r = ll % l;
 
@@ -2198,6 +2353,22 @@ static void TestRegExInteractive()
 
 #endif // TEST_REGEX
 
+// ----------------------------------------------------------------------------
+// database
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_ODBC
+
+#include <wx/db.h>
+
+static void TestDbOpen()
+{
+    HENV henv;
+    wxDb db(henv);
+}
+
+#endif // TEST_ODBC
+
 // ----------------------------------------------------------------------------
 // registry and related stuff
 // ----------------------------------------------------------------------------
@@ -4454,7 +4625,7 @@ void MyDetachedThread::OnExit()
         gs_cond.Signal();
 }
 
-void TestDetachedThreads()
+static void TestDetachedThreads()
 {
     puts("\n*** Testing detached threads ***");
 
@@ -4480,7 +4651,7 @@ void TestDetachedThreads()
     puts("");
 }
 
-void TestJoinableThreads()
+static void TestJoinableThreads()
 {
     puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
 
@@ -4492,7 +4663,7 @@ void TestJoinableThreads()
            (unsigned long)thread.Wait());
 }
 
-void TestThreadSuspend()
+static void TestThreadSuspend()
 {
     puts("\n*** Testing thread suspend/resume functions ***");
 
@@ -4531,7 +4702,7 @@ void TestThreadSuspend()
     puts("");
 }
 
-void TestThreadDelete()
+static void TestThreadDelete()
 {
     // As above, using Sleep() is only for testing here - we must use some
     // synchronisation object instead to ensure that the thread is still
@@ -4587,6 +4758,99 @@ void TestThreadDelete()
     puts("");
 }
 
+class MyWaitingThread : public wxThread
+{
+public:
+    MyWaitingThread(wxCondition *condition)
+    {
+        m_condition = condition;
+
+        Create();
+    }
+
+    virtual ExitCode Entry()
+    {
+        printf("Thread %lu has started running.\n", GetId());
+        fflush(stdout);
+
+        gs_cond.Signal();
+
+        printf("Thread %lu starts to wait...\n", GetId());
+        fflush(stdout);
+
+        m_condition->Wait();
+
+        printf("Thread %lu finished to wait, exiting.\n", GetId());
+        fflush(stdout);
+
+        return 0;
+    }
+
+private:
+    wxCondition *m_condition;
+};
+
+static void TestThreadConditions()
+{
+    wxCondition condition;
+
+    // otherwise its difficult to understand which log messages pertain to
+    // which condition
+    wxLogTrace("thread", "Local condition var is %08x, gs_cond = %08x",
+               condition.GetId(), gs_cond.GetId());
+
+    // create and launch threads
+    MyWaitingThread *threads[10];
+
+    size_t n;
+    for ( n = 0; n < WXSIZEOF(threads); n++ )
+    {
+        threads[n] = new MyWaitingThread(&condition);
+    }
+
+    for ( n = 0; n < WXSIZEOF(threads); n++ )
+    {
+        threads[n]->Run();
+    }
+
+    // wait until all threads run
+    puts("Main thread is waiting for the other threads to start");
+    fflush(stdout);
+
+    size_t nRunning = 0;
+    while ( nRunning < WXSIZEOF(threads) )
+    {
+        gs_cond.Wait();
+
+        nRunning++;
+
+        printf("Main thread: %u already running\n", nRunning);
+        fflush(stdout);
+    }
+
+    puts("Main thread: all threads started up.");
+    fflush(stdout);
+
+    wxThread::Sleep(500);
+
+#if 1
+    // now wake one of them up
+    printf("Main thread: about to signal the condition.\n");
+    fflush(stdout);
+    condition.Signal();
+#endif
+
+    wxThread::Sleep(200);
+
+    // wake all the (remaining) threads up, so that they can exit
+    printf("Main thread: about to broadcast the condition.\n");
+    fflush(stdout);
+    condition.Broadcast();
+
+    // give them time to terminate (dirty!)
+    wxThread::Sleep(500);
+}
+
 #endif // TEST_THREADS
 
 // ----------------------------------------------------------------------------
@@ -4595,25 +4859,46 @@ void TestThreadDelete()
 
 #ifdef TEST_ARRAYS
 
-static void PrintArray(const char* name, const wxArrayString& array)
-{
-    printf("Dump of the array '%s'\n", name);
+#include "wx/dynarray.h"
 
-    size_t nCount = array.GetCount();
-    for ( size_t n = 0; n < nCount; n++ )
-    {
-        printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
-    }
-}
+#define DefineCompare(name, T)                                                \
+                                                                              \
+int wxCMPFUNC_CONV name ## CompareValues(T first, T second)                   \
+{                                                                             \
+    return first - second;                                                    \
+}                                                                             \
+                                                                              \
+int wxCMPFUNC_CONV name ## Compare(T* first, T* second)                       \
+{                                                                             \
+    return *first - *second;                                                  \
+}                                                                             \
+                                                                              \
+int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second)                    \
+{                                                                             \
+    return *second - *first;                                                  \
+}                                                                             \
+
+DefineCompare(Short, short);
+DefineCompare(Int, int);
+
+// test compilation of all macros
+WX_DEFINE_ARRAY(short, wxArrayShort);
+WX_DEFINE_SORTED_ARRAY(short, wxSortedArrayShortNoCmp);
+WX_DEFINE_SORTED_ARRAY_CMP(short, ShortCompareValues, wxSortedArrayShort);
+WX_DEFINE_SORTED_ARRAY_CMP(int, IntCompareValues, wxSortedArrayInt);
+
+WX_DECLARE_OBJARRAY(Bar, ArrayBars);
+#include "wx/arrimpl.cpp"
+WX_DEFINE_OBJARRAY(ArrayBars);
 
-static void PrintArray(const char* name, const wxArrayInt& array)
+static void PrintArray(const char* name, const wxArrayString& array)
 {
     printf("Dump of the array '%s'\n", name);
 
     size_t nCount = array.GetCount();
     for ( size_t n = 0; n < nCount; n++ )
     {
-        printf("\t%s[%u] = %d\n", name, n, array[n]);
+        printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
     }
 }
 
@@ -4623,45 +4908,63 @@ int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
     return first.length() - second.length();
 }
 
-int wxCMPFUNC_CONV IntCompare(int *first,
-                              int *second)
-{
-    return *first - *second;
-}
-
-int wxCMPFUNC_CONV IntRevCompare(int *first,
-                              int *second)
-{
-    return *second - *first;
-}
-
-static void TestArrayOfInts()
-{
-    puts("*** Testing wxArrayInt ***\n");
-
-    wxArrayInt a;
-    a.Add(1);
-    a.Add(17);
-    a.Add(5);
-    a.Add(3);
-
-    puts("Initially:");
-    PrintArray("a", a);
-
-    puts("After sort:");
-    a.Sort(IntCompare);
-    PrintArray("a", a);
-
-    puts("After reverse sort:");
-    a.Sort(IntRevCompare);
-    PrintArray("a", a);
+#define TestArrayOf(name)                                                     \
+                                                                              \
+static void PrintArray(const char* name, const wxSortedArray##name & array)   \
+{                                                                             \
+    printf("Dump of the array '%s'\n", name);                                 \
+                                                                              \
+    size_t nCount = array.GetCount();                                         \
+    for ( size_t n = 0; n < nCount; n++ )                                     \
+    {                                                                         \
+        printf("\t%s[%u] = %d\n", name, n, array[n]);                         \
+    }                                                                         \
+}                                                                             \
+                                                                              \
+static void PrintArray(const char* name, const wxArray##name & array)         \
+{                                                                             \
+    printf("Dump of the array '%s'\n", name);                                 \
+                                                                              \
+    size_t nCount = array.GetCount();                                         \
+    for ( size_t n = 0; n < nCount; n++ )                                     \
+    {                                                                         \
+        printf("\t%s[%u] = %d\n", name, n, array[n]);                         \
+    }                                                                         \
+}                                                                             \
+                                                                              \
+static void TestArrayOf ## name ## s()                                        \
+{                                                                             \
+    printf("*** Testing wxArray%s ***\n", #name);                             \
+                                                                              \
+    wxArray##name a;                                                          \
+    a.Add(1);                                                                 \
+    a.Add(17);                                                                \
+    a.Add(5);                                                                 \
+    a.Add(3);                                                                 \
+                                                                              \
+    puts("Initially:");                                                       \
+    PrintArray("a", a);                                                       \
+                                                                              \
+    puts("After sort:");                                                      \
+    a.Sort(name ## Compare);                                                  \
+    PrintArray("a", a);                                                       \
+                                                                              \
+    puts("After reverse sort:");                                              \
+    a.Sort(name ## RevCompare);                                               \
+    PrintArray("a", a);                                                       \
+                                                                              \
+    wxSortedArray##name b;                                                    \
+    b.Add(1);                                                                 \
+    b.Add(17);                                                                \
+    b.Add(5);                                                                 \
+    b.Add(3);                                                                 \
+                                                                              \
+    puts("Sorted array initially:");                                          \
+    PrintArray("b", b);                                                       \
 }
 
-#include "wx/dynarray.h"
-
-WX_DECLARE_OBJARRAY(Bar, ArrayBars);
-#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(ArrayBars);
+TestArrayOf(Short);
+TestArrayOf(Int);
 
 static void TestArrayOfObjects()
 {
@@ -5236,11 +5539,10 @@ int main(int argc, char **argv)
         PrintArray("a1", a1);
 
         TestArrayOfObjects();
+        TestArrayOfShorts();
     }
-    else
-    {
-        TestArrayOfInts();
-    }
+
+    TestArrayOfInts();
 #endif // TEST_ARRAYS
 
 #ifdef TEST_DIR
@@ -5304,7 +5606,7 @@ int main(int argc, char **argv)
 #endif // TEST_FILE
 
 #ifdef TEST_FILENAME
-    if ( 0 )
+    if ( 1 )
     {
         wxFileName fn;
         fn.Assign("c:\\foo", "bar.baz");
@@ -5351,26 +5653,6 @@ int main(int argc, char **argv)
         TestFtpWuFtpd();
 #endif // TEST_FTP
 
-#ifdef TEST_THREADS
-    int nCPUs = wxThread::GetCPUCount();
-    printf("This system has %d CPUs\n", nCPUs);
-    if ( nCPUs != -1 )
-        wxThread::SetConcurrency(nCPUs);
-
-    if ( argc > 1 && argv[1][0] == 't' )
-        wxLog::AddTraceMask("thread");
-
-    if ( 1 )
-        TestDetachedThreads();
-    if ( 1 )
-        TestJoinableThreads();
-    if ( 1 )
-        TestThreadSuspend();
-    if ( 1 )
-        TestThreadDelete();
-
-#endif // TEST_THREADS
-
 #ifdef TEST_LONGLONG
     // seed pseudo random generator
     srand((unsigned)time(NULL));
@@ -5396,16 +5678,20 @@ int main(int argc, char **argv)
     TestHash();
 #endif // TEST_HASH
 
+#ifdef TEST_HASHMAP
+    TestHashMap();
+#endif // TEST_HASHMAP
+
 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));
-    if ( 1 )
+    if ( TEST_ALL )
     {
         TestMimeEnum();
         TestMimeOverride();
         TestMimeFilename();
     }
-    else
-        TestMimeAssociate();
+
+    TestMimeAssociate();
 #endif // TEST_MIME
 
 #ifdef TEST_INFO_FUNCTIONS
@@ -5413,7 +5699,9 @@ int main(int argc, char **argv)
     {
         TestOsInfo();
         TestUserInfo();
-        TestDiskInfo();
+
+        if ( TEST_INTERACTIVE )
+            TestDiskInfo();
     }
 #endif // TEST_INFO_FUNCTIONS
 
@@ -5421,6 +5709,10 @@ int main(int argc, char **argv)
     TestPathList();
 #endif // TEST_PATHLIST
 
+#ifdef TEST_ODBC
+    TestDbOpen();
+#endif // TEST_ODBC
+
 #ifdef TEST_REGCONF
     TestRegConfWrite();
 #endif // TEST_REGCONF
@@ -5454,6 +5746,23 @@ int main(int argc, char **argv)
     TestMemoryStream();
 #endif // TEST_STREAMS
 
+#ifdef TEST_THREADS
+    int nCPUs = wxThread::GetCPUCount();
+    printf("This system has %d CPUs\n", nCPUs);
+    if ( nCPUs != -1 )
+        wxThread::SetConcurrency(nCPUs);
+
+    if ( TEST_ALL )
+    {
+        TestDetachedThreads();
+        TestJoinableThreads();
+        TestThreadSuspend();
+        TestThreadDelete();
+    }
+
+    TestThreadConditions();
+#endif // TEST_THREADS
+
 #ifdef TEST_TIMER
     TestStopWatch();
 #endif // TEST_TIMER