]> git.saurik.com Git - wxWidgets.git/blobdiff - samples/console/console.cpp
fixed bug with the caret positioning after SetValue() introduced by the last commit
[wxWidgets.git] / samples / console / console.cpp
index 242fa887a26a629006e48d5eb778ea7df4537dad..c727d7ffe96f93f6581401faa7d62bce8dc1ee54 100644 (file)
 // headers
 // ----------------------------------------------------------------------------
 
+#include "wx/defs.h"
+
+#if wxUSE_GUI
+    #error "This sample can't be compiled in GUI mode."
+#endif // wxUSE_GUI
+
 #include <stdio.h>
 
-#include <wx/string.h>
-#include <wx/file.h>
-#include <wx/app.h>
+#include "wx/string.h"
+#include "wx/file.h"
+#include "wx/app.h"
 
 // without this pragma, the stupid compiler precompiles #defines below so that
 // changing them doesn't "take place" later!
 // conditional compilation
 // ----------------------------------------------------------------------------
 
-// what to test (in alphabetic order)?
-
-//#define TEST_ARRAYS
-//#define TEST_CMDLINE
-//#define TEST_DATETIME
-//#define TEST_DIR
-//#define TEST_DLLLOADER
-//#define TEST_ENVIRON
-//#define TEST_EXECUTE
-//#define TEST_FILE
-//#define TEST_FILECONF
-//#define TEST_FILENAME
-//#define TEST_FTP
-//#define TEST_HASH
-//#define TEST_INFO_FUNCTIONS
-//#define TEST_LIST
-//#define TEST_LOCALE
-//#define TEST_LOG
-//#define TEST_LONGLONG
-//#define TEST_MIME
-//#define TEST_PATHLIST
-#define TEST_REGCONF
-//#define TEST_REGISTRY
-//#define TEST_SOCKETS
-//#define TEST_STREAMS
-//#define TEST_STRINGS
-//#define TEST_THREADS
-//#define TEST_TIMER
-//#define TEST_VCARD            -- don't enable this (VZ)
-//#define TEST_WCHAR
-//#define TEST_ZIP
-//#define TEST_ZLIB
-
-
-#ifdef TEST_DATETIME
-#include <math.h>
+// what to test (in alphabetic order)? uncomment the line below to do all tests
+//#define TEST_ALL
+#ifdef TEST_ALL
+    #define TEST_ARRAYS
+    #define TEST_CHARSET
+    #define TEST_CMDLINE
+    #define TEST_DATETIME
+    #define TEST_DIR
+    #define TEST_DLLLOADER
+    #define TEST_ENVIRON
+    #define TEST_EXECUTE
+    #define TEST_FILE
+    #define TEST_FILECONF
+    #define TEST_FILENAME
+    #define TEST_FILETIME
+    #define TEST_FTP
+    #define TEST_HASH
+    #define TEST_INFO_FUNCTIONS
+    #define TEST_LIST
+    #define TEST_LOCALE
+    #define TEST_LOG
+    #define TEST_LONGLONG
+    #define TEST_MIME
+    #define TEST_PATHLIST
+    #define TEST_REGCONF
+    #define TEST_REGEX
+    #define TEST_REGISTRY
+    #define TEST_SNGLINST
+    #define TEST_SOCKETS
+    #define TEST_STREAMS
+    #define TEST_STRINGS
+    #define TEST_THREADS
+    #define TEST_TIMER
+    // #define TEST_VCARD            -- don't enable this (VZ)
+    #define TEST_WCHAR
+    #define TEST_ZIP
+    #define TEST_ZLIB
+#else
+    #define TEST_FILENAME
 #endif
 
+#ifdef TEST_SNGLINST
+    #include "wx/snglinst.h"
+#endif // TEST_SNGLINST
 
 // ----------------------------------------------------------------------------
 // test class for container objects
@@ -121,14 +133,56 @@ static wxString MakePrintable(const wxChar *s)
 
 #endif // MakePrintable() is used
 
+// ----------------------------------------------------------------------------
+// wxFontMapper::CharsetToEncoding
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_CHARSET
+
+#include "wx/fontmap.h"
+
+static void TestCharset()
+{
+    static const wxChar *charsets[] =
+    {
+        // some vali charsets
+        _T("us-ascii    "),
+        _T("iso8859-1   "),
+        _T("iso-8859-12 "),
+        _T("koi8-r      "),
+        _T("utf-7       "),
+        _T("cp1250      "),
+        _T("windows-1252"),
+
+        // and now some bogus ones
+        _T("            "),
+        _T("cp1249      "),
+        _T("iso--8859-1 "),
+        _T("iso-8859-19 "),
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
+    {
+        wxFontEncoding enc = wxTheFontMapper->CharsetToEncoding(charsets[n]);
+        wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
+                 charsets[n],
+                 wxTheFontMapper->GetEncodingName(enc).c_str(),
+                 wxTheFontMapper->GetEncodingDescription(enc).c_str());
+    }
+}
+
+#endif // TEST_CHARSET
+
 // ----------------------------------------------------------------------------
 // wxCmdLineParser
 // ----------------------------------------------------------------------------
 
 #ifdef TEST_CMDLINE
 
-#include <wx/cmdline.h>
-#include <wx/datetime.h>
+#include "wx/cmdline.h"
+#include "wx/datetime.h"
+
+#if wxUSE_CMDLINE_PARSER
 
 static void ShowCmdLine(const wxCmdLineParser& parser)
 {
@@ -161,6 +215,32 @@ static void ShowCmdLine(const wxCmdLineParser& parser)
     wxLogMessage(s);
 }
 
+#endif // wxUSE_CMDLINE_PARSER
+
+static void TestCmdLineConvert()
+{
+    static const char *cmdlines[] =
+    {
+        "arg1 arg2",
+        "-a \"-bstring 1\" -c\"string 2\" \"string 3\"",
+        "literal \\\" and \"\"",
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
+    {
+        const char *cmdline = cmdlines[n];
+        printf("Parsing: %s\n", cmdline);
+        wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
+
+        size_t count = args.GetCount();
+        printf("\targc = %u\n", count);
+        for ( size_t arg = 0; arg < count; arg++ )
+        {
+            printf("\targv[%u] = %s\n", arg, args[arg]);
+        }
+    }
+}
+
 #endif // TEST_CMDLINE
 
 // ----------------------------------------------------------------------------
@@ -169,7 +249,17 @@ static void ShowCmdLine(const wxCmdLineParser& parser)
 
 #ifdef TEST_DIR
 
-#include <wx/dir.h>
+#include "wx/dir.h"
+
+#ifdef __UNIX__
+    static const wxChar *ROOTDIR = _T("/");
+    static const wxChar *TESTDIR = _T("/usr");
+#elif defined(__WXMSW__)
+    static const wxChar *ROOTDIR = _T("c:\\");
+    static const wxChar *TESTDIR = _T("d:\\");
+#else
+    #error "don't know where the root directory is"
+#endif
 
 static void TestDirEnumHelper(wxDir& dir,
                               int flags = wxDIR_DEFAULT,
@@ -193,6 +283,8 @@ static void TestDirEnumHelper(wxDir& dir,
 
 static void TestDirEnum()
 {
+    puts("*** Testing wxDir::GetFirst/GetNext ***");
+
     wxDir dir(wxGetCwd());
 
     puts("Enumerating everything in current directory:");
@@ -213,13 +305,7 @@ static void TestDirEnum()
     puts("Enumerating files including hidden in current directory:");
     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 
-#ifdef __UNIX__
-    dir.Open("/");
-#elif defined(__WXMSW__)
-    dir.Open("c:\\");
-#else
-    #error "don't know where the root directory is"
-#endif
+    dir.Open(ROOTDIR);
 
     puts("Enumerating everything in root directory:");
     TestDirEnumHelper(dir, wxDIR_DEFAULT);
@@ -238,6 +324,55 @@ static void TestDirEnum()
     TestDirEnumHelper(dirNo);
 }
 
+class DirPrintTraverser : public wxDirTraverser
+{
+public:
+    virtual wxDirTraverseResult OnFile(const wxString& filename)
+    {
+        return wxDIR_CONTINUE;
+    }
+
+    virtual wxDirTraverseResult OnDir(const wxString& dirname)
+    {
+        wxString path, name, ext;
+        wxSplitPath(dirname, &path, &name, &ext);
+
+        if ( !ext.empty() )
+            name << _T('.') << ext;
+
+        wxString indent;
+        for ( const wxChar *p = path.c_str(); *p; p++ )
+        {
+            if ( wxIsPathSeparator(*p) )
+                indent += _T("    ");
+        }
+
+        printf("%s%s\n", indent.c_str(), name.c_str());
+
+        return wxDIR_CONTINUE;
+    }
+};
+
+static void TestDirTraverse()
+{
+    puts("*** Testing wxDir::Traverse() ***");
+
+    // enum all files
+    wxArrayString files;
+    size_t n = wxDir::GetAllFiles(TESTDIR, &files);
+    printf("There are %u files under '%s'\n", n, TESTDIR);
+    if ( n > 1 )
+    {
+        printf("First one is '%s'\n", files[0u].c_str());
+        printf(" last one is '%s'\n", files[n - 1].c_str());
+    }
+
+    // enum again with custom traverser
+    wxDir dir(TESTDIR);
+    DirPrintTraverser traverser;
+    dir.Traverse(traverser, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
+}
+
 #endif // TEST_DIR
 
 // ----------------------------------------------------------------------------
@@ -246,7 +381,7 @@ static void TestDirEnum()
 
 #ifdef TEST_DLLLOADER
 
-#include <wx/dynlib.h>
+#include "wx/dynlib.h"
 
 static void TestDllLoad()
 {
@@ -270,7 +405,7 @@ static void TestDllLoad()
     }
     else
     {
-        typedef int (*strlenType)(char *);
+        typedef int (*strlenType)(const char *);
         strlenType pfnStrlen = (strlenType)wxDllLoader::GetSymbol(dllHandle, FUNC_NAME);
         if ( !pfnStrlen )
         {
@@ -301,7 +436,7 @@ static void TestDllLoad()
 
 #ifdef TEST_ENVIRON
 
-#include <wx/utils.h>
+#include "wx/utils.h"
 
 static wxString MyGetEnv(const wxString& var)
 {
@@ -327,7 +462,7 @@ static void TestEnvironment()
     printf("After 2nd wxSetEnv: getenv(%s) = %s\n",  var, MyGetEnv(var).c_str());
     wxUnsetEnv(var);
     printf("After wxUnsetEnv: getenv(%s) = %s\n",  var, MyGetEnv(var).c_str());
-    printf("PATH = %s\n",  MyGetEnv(_T("PATH")));
+    printf("PATH = %s\n",  MyGetEnv(_T("PATH")).c_str());
 }
 
 #endif // TEST_ENVIRON
@@ -338,7 +473,7 @@ static void TestEnvironment()
 
 #ifdef TEST_EXECUTE
 
-#include <wx/utils.h>
+#include "wx/utils.h"
 
 static void TestExecute()
 {
@@ -405,9 +540,9 @@ static void TestExecute()
 
 #ifdef TEST_FILE
 
-#include <wx/file.h>
-#include <wx/ffile.h>
-#include <wx/textfile.h>
+#include "wx/file.h"
+#include "wx/ffile.h"
+#include "wx/textfile.h"
 
 static void TestFileRead()
 {
@@ -540,8 +675,8 @@ static void TestFileCopy()
 
 #ifdef TEST_FILECONF
 
-#include <wx/confbase.h>
-#include <wx/fileconf.h>
+#include "wx/confbase.h"
+#include "wx/fileconf.h"
 
 static const struct FileConfTestData
 {
@@ -603,24 +738,58 @@ static void TestFileConfRead()
 
 #ifdef TEST_FILENAME
 
-#include <wx/filename.h>
+#include "wx/filename.h"
+
+static void DumpFileName(const wxFileName& fn)
+{
+    wxString full = fn.GetFullPath();
+
+    wxString vol, path, name, ext;
+    wxFileName::SplitPath(full, &vol, &path, &name, &ext);
+
+    wxPrintf(_T("Filename '%s' -> vol '%s', path '%s', name '%s', ext '%s'\n"),
+             full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
+}
 
 static struct FileNameInfo
 {
     const wxChar *fullname;
+    const wxChar *volume;
     const wxChar *path;
     const wxChar *name;
     const wxChar *ext;
+    bool isAbsolute;
+    wxPathFormat format;
 } filenames[] =
 {
-    { _T("/usr/bin/ls"), _T("/usr/bin"), _T("ls"), _T("") },
-    { _T("/usr/bin/"), _T("/usr/bin"), _T(""), _T("") },
-    { _T("~/.zshrc"), _T("~"), _T(".zshrc"), _T("") },
-    { _T("../../foo"), _T("../.."), _T("foo"), _T("") },
-    { _T("foo.bar"), _T(""), _T("foo"), _T("bar") },
-    { _T("~/foo.bar"), _T("~"), _T("foo"), _T("bar") },
-    { _T("Mahogany-0.60/foo.bar"), _T("Mahogany-0.60"), _T("foo"), _T("bar") },
-    { _T("/tmp/wxwin.tar.bz"), _T("/tmp"), _T("wxwin.tar"), _T("bz") },
+    // Unix file names
+    { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), TRUE, wxPATH_UNIX },
+    { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), TRUE, wxPATH_UNIX },
+    { _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), TRUE, wxPATH_UNIX },
+    { _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), FALSE, wxPATH_UNIX },
+    { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
+    { _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), TRUE, wxPATH_UNIX },
+    { _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), TRUE, wxPATH_UNIX },
+    { _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
+    { _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), TRUE, wxPATH_UNIX },
+
+    // Windows file names
+    { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
+    { _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
+    { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
+    { _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
+    { _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), TRUE, wxPATH_DOS },
+    { _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
+
+    // Mac file names
+    { _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
+    { _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), FALSE, wxPATH_MAC },
+    { _T(":File"), _T(""), _T(""), _T("File"), _T(""), FALSE, wxPATH_MAC },
+    { _T("File"), _T(""), _T(""), _T("File"), _T(""), FALSE, wxPATH_MAC },
+
+    // VMS file names
+    { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE, wxPATH_VMS },
+    { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), FALSE, wxPATH_VMS },
 };
 
 static void TestFileNameConstruction()
@@ -629,16 +798,29 @@ static void TestFileNameConstruction()
 
     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
     {
-        wxFileName fn(filenames[n].fullname, wxPATH_UNIX);
+        const FileNameInfo& fni = filenames[n];
+
+        wxFileName fn(fni.fullname, fni.format);
+
+        wxString fullname = fn.GetFullPath(fni.format);
+        if ( fullname != fni.fullname )
+        {
+            printf("ERROR: fullname should be '%s'\n", fni.fullname);
+        }
+
+        bool isAbsolute = fn.IsAbsolute(fni.format);
+        printf("'%s' is %s (%s)\n\t",
+               fullname.c_str(),
+               isAbsolute ? "absolute" : "relative",
+               isAbsolute == fni.isAbsolute ? "ok" : "ERROR");
 
-        printf("Filename: '%s'\t", fn.GetFullPath().c_str());
-        if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), wxPATH_UNIX) )
+        if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), fni.format) )
         {
             puts("ERROR (couldn't be normalized)");
         }
         else
         {
-            printf("normalized: '%s'\n", fn.GetFullPath().c_str());
+            printf("normalized: '%s'\n", fn.GetFullPath(fni.format).c_str());
         }
     }
 
@@ -651,22 +833,97 @@ static void TestFileNameSplit()
 
     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
     {
-        const FileNameInfo &fni = filenames[n];
-        wxString path, name, ext;
-        wxFileName::SplitPath(fni.fullname, &path, &name, &ext);
+        const FileNameInfo& fni = filenames[n];
+        wxString volume, path, name, ext;
+        wxFileName::SplitPath(fni.fullname,
+                              &volume, &path, &name, &ext, fni.format);
+
+        printf("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'",
+               fni.fullname,
+               volume.c_str(), path.c_str(), name.c_str(), ext.c_str());
 
-        printf("%s -> path = '%s', name = '%s', ext = '%s'",
-               fni.fullname, path.c_str(), name.c_str(), ext.c_str());
+        if ( volume != fni.volume )
+            printf(" (ERROR: volume = '%s')", fni.volume);
         if ( path != fni.path )
             printf(" (ERROR: path = '%s')", fni.path);
         if ( name != fni.name )
             printf(" (ERROR: name = '%s')", fni.name);
         if ( ext != fni.ext )
             printf(" (ERROR: ext = '%s')", fni.ext);
+
         puts("");
     }
+}
 
-    puts("");
+static void TestFileNameTemp()
+{
+    puts("*** testing wxFileName temp file creation ***");
+
+    static const char *tmpprefixes[] =
+    {
+        "foo",
+        "/tmp/foo",
+        "..",
+        "../bar",
+        "/tmp/foo/bar", // this one must be an error
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
+    {
+        wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
+        if ( !path.empty() )
+        {
+            printf("Prefix '%s'\t-> temp file '%s'\n",
+                   tmpprefixes[n], path.c_str());
+
+            if ( !wxRemoveFile(path) )
+            {
+                wxLogWarning("Failed to remove temp file '%s'", path.c_str());
+            }
+        }
+    }
+}
+
+static void TestFileNameMakeRelative()
+{
+    puts("*** testing wxFileName::MakeRelativeTo() ***");
+
+    for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
+    {
+        const FileNameInfo& fni = filenames[n];
+
+        wxFileName fn(fni.fullname, fni.format);
+
+        // choose the base dir of the same format
+        wxString base;
+        switch ( fni.format )
+        {
+            case wxPATH_UNIX:
+                base = "/usr/bin/";
+                break;
+
+            case wxPATH_DOS:
+                base = "c:\\";
+                break;
+
+            case wxPATH_MAC:
+            case wxPATH_VMS:
+                // TODO: I don't know how this is supposed to work there
+                continue;
+        }
+
+        printf("'%s' relative to '%s': ",
+               fn.GetFullPath(fni.format).c_str(), base.c_str());
+
+        if ( !fn.MakeRelativeTo(base, fni.format) )
+        {
+            puts("unchanged");
+        }
+        else
+        {
+            printf("'%s'\n", fn.GetFullPath(fni.format).c_str());
+        }
+    }
 }
 
 static void TestFileNameComparison()
@@ -686,13 +943,55 @@ static void TestFileNameCwd()
 
 #endif // TEST_FILENAME
 
+// ----------------------------------------------------------------------------
+// wxFileName time functions
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_FILETIME
+
+#include <wx/filename.h>
+#include <wx/datetime.h>
+
+static void TestFileGetTimes()
+{
+    wxFileName fn(_T("testdata.fc"));
+
+    wxDateTime dtAccess, dtMod, dtChange;
+    if ( !fn.GetTimes(&dtAccess, &dtMod, &dtChange) )
+    {
+        wxPrintf(_T("ERROR: GetTimes() failed.\n"));
+    }
+    else
+    {
+        static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
+
+        wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
+        wxPrintf(_T("Access:      \t%s\n"), dtAccess.Format(fmt).c_str());
+        wxPrintf(_T("Mod/creation:\t%s\n"), dtMod.Format(fmt).c_str());
+        wxPrintf(_T("Change:      \t%s\n"), dtChange.Format(fmt).c_str());
+    }
+}
+
+static void TestFileSetTimes()
+{
+    wxFileName fn(_T("testdata.fc"));
+
+    wxDateTime dtAccess, dtMod, dtChange;
+    if ( !fn.Touch() )
+    {
+        wxPrintf(_T("ERROR: Touch() failed.\n"));
+    }
+}
+
+#endif // TEST_FILETIME
+
 // ----------------------------------------------------------------------------
 // wxHashTable
 // ----------------------------------------------------------------------------
 
 #ifdef TEST_HASH
 
-#include <wx/hash.h>
+#include "wx/hash.h"
 
 struct Foo
 {
@@ -709,7 +1008,7 @@ size_t Foo::count = 0;
 WX_DECLARE_LIST(Foo, wxListFoos);
 WX_DECLARE_HASH(Foo, wxListFoos, wxHashFoos);
 
-#include <wx/listimpl.cpp>
+#include "wx/listimpl.cpp"
 
 WX_DEFINE_LIST(wxListFoos);
 
@@ -778,10 +1077,10 @@ static void TestHash()
 
 #ifdef TEST_LIST
 
-#include <wx/list.h>
+#include "wx/list.h"
 
 WX_DECLARE_LIST(Bar, wxListBars);
-#include <wx/listimpl.cpp>
+#include "wx/listimpl.cpp"
 WX_DEFINE_LIST(wxListBars);
 
 static void TestListCtor()
@@ -1083,11 +1382,19 @@ static void TestDefaultLang()
         _T("klingonese"),   // I bet on some systems it does exist...
     };
 
+    wxPrintf(_T("The default system encoding is %s (%d)\n"),
+             wxLocale::GetSystemEncodingName().c_str(),
+             wxLocale::GetSystemEncoding());
+
     for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
     {
         const char *langStr = langStrings[n];
         if ( langStr )
+        {
+            // FIXME: this doesn't do anything at all under Windows, we need
+            //        to create a new wxLocale!
             wxSetEnv(_T("LC_ALL"), langStr);
+        }
 
         int lang = gs_localeDefault.GetSystemLanguage();
         printf("Locale for '%s' is %s.\n",
@@ -1103,7 +1410,7 @@ static void TestDefaultLang()
 
 #ifdef TEST_MIME
 
-#include <wx/mimetype.h>
+#include "wx/mimetype.h"
 
 static void TestMimeEnum()
 {
@@ -1252,7 +1559,36 @@ static void TestMimeAssociate()
 
 #ifdef TEST_INFO_FUNCTIONS
 
-#include <wx/utils.h>
+#include "wx/utils.h"
+
+static void TestDiskInfo()
+{
+    puts("*** Testing wxGetDiskSpace() ***");
+
+    for ( ;; )
+    {
+        char pathname[128];
+        printf("\nEnter a directory name: ");
+        if ( !fgets(pathname, WXSIZEOF(pathname), stdin) )
+            break;
+
+        // kill the last '\n'
+        pathname[strlen(pathname) - 1] = 0;
+
+        wxLongLong total, free;
+        if ( !wxGetDiskSpace(pathname, &total, &free) )
+        {
+            wxPuts(_T("ERROR: wxGetDiskSpace failed."));
+        }
+        else
+        {
+            wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
+                    (total / 1024).ToString().c_str(),
+                    (free / 1024).ToString().c_str(),
+                    pathname);
+        }
+    }
+}
 
 static void TestOsInfo()
 {
@@ -1291,8 +1627,8 @@ static void TestUserInfo()
 
 #ifdef TEST_LONGLONG
 
-#include <wx/longlong.h>
-#include <wx/timer.h>
+#include "wx/longlong.h"
+#include "wx/timer.h"
 
 // make a 64 bit number from 4 16 bit ones
 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
@@ -1300,6 +1636,17 @@ static void TestUserInfo()
 // get a random 64 bit number
 #define RAND_LL()   MAKE_LL(rand(), rand(), rand(), rand())
 
+static const long testLongs[] =
+{
+    0,
+    1,
+    -1,
+    LONG_MAX,
+    LONG_MIN,
+    0x1234,
+    -0x1234
+};
+
 #if wxUSE_LONGLONG_WX
 inline bool operator==(const wxLongLongWx& a, const wxLongLongNative& b)
     { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
@@ -1522,19 +1869,9 @@ static void TestBitOperations()
 
 static void TestLongLongComparison()
 {
+#if wxUSE_LONGLONG_WX
     puts("*** Testing wxLongLong comparison ***\n");
 
-    static const long testLongs[] =
-    {
-        0,
-        1,
-        -1,
-        LONG_MAX,
-        LONG_MIN,
-        0x1234,
-        -0x1234
-    };
-
     static const long ls[2] =
     {
         0x1234,
@@ -1543,7 +1880,7 @@ static void TestLongLongComparison()
 
     wxLongLongWx lls[2];
     lls[0] = ls[0];
-    lls[1] = ls[1]; 
+    lls[1] = ls[1];
 
     for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
     {
@@ -1567,6 +1904,24 @@ static void TestLongLongComparison()
                    res == (ls[m] == testLongs[n]) ? "ok" : "ERROR");
         }
     }
+#endif // wxUSE_LONGLONG_WX
+}
+
+static void TestLongLongPrint()
+{
+    wxPuts(_T("*** Testing wxLongLong printing ***\n"));
+
+    for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
+    {
+        wxLongLong ll = testLongs[n];
+        wxPrintf(_T("%ld == %s\n"), testLongs[n], ll.ToString().c_str());
+    }
+
+    wxLongLong ll(0x12345678, 0x87654321);
+    wxPrintf(_T("0x1234567887654321 = %s\n"), ll.ToString().c_str());
+
+    ll.Negate();
+    wxPrintf(_T("-0x1234567887654321 = %s\n"), ll.ToString().c_str());
 }
 
 #undef MAKE_LL
@@ -1599,6 +1954,227 @@ static void TestPathList()
 
 #endif // TEST_PATHLIST
 
+// ----------------------------------------------------------------------------
+// regular expressions
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_REGEX
+
+#include "wx/regex.h"
+
+static void TestRegExCompile()
+{
+    wxPuts(_T("*** Testing RE compilation ***\n"));
+
+    static struct RegExCompTestData
+    {
+        const wxChar *pattern;
+        bool correct;
+    } regExCompTestData[] =
+    {
+        { _T("foo"), TRUE },
+        { _T("foo("), FALSE },
+        { _T("foo(bar"), FALSE },
+        { _T("foo(bar)"), TRUE },
+        { _T("foo["), FALSE },
+        { _T("foo[bar"), FALSE },
+        { _T("foo[bar]"), TRUE },
+        { _T("foo{"), TRUE },
+        { _T("foo{1"), FALSE },
+        { _T("foo{bar"), TRUE },
+        { _T("foo{1}"), TRUE },
+        { _T("foo{1,2}"), TRUE },
+        { _T("foo{bar}"), TRUE },
+        { _T("foo*"), TRUE },
+        { _T("foo**"), FALSE },
+        { _T("foo+"), TRUE },
+        { _T("foo++"), FALSE },
+        { _T("foo?"), TRUE },
+        { _T("foo??"), FALSE },
+        { _T("foo?+"), FALSE },
+    };
+
+    wxRegEx re;
+    for ( size_t n = 0; n < WXSIZEOF(regExCompTestData); n++ )
+    {
+        const RegExCompTestData& data = regExCompTestData[n];
+        bool ok = re.Compile(data.pattern);
+
+        wxPrintf(_T("'%s' is %sa valid RE (%s)\n"),
+                 data.pattern,
+                 ok ? _T("") : _T("not "),
+                 ok == data.correct ? _T("ok") : _T("ERROR"));
+    }
+}
+
+static void TestRegExMatch()
+{
+    wxPuts(_T("*** Testing RE matching ***\n"));
+
+    static struct RegExMatchTestData
+    {
+        const wxChar *pattern;
+        const wxChar *text;
+        bool correct;
+    } regExMatchTestData[] =
+    {
+        { _T("foo"), _T("bar"), FALSE },
+        { _T("foo"), _T("foobar"), TRUE },
+        { _T("^foo"), _T("foobar"), TRUE },
+        { _T("^foo"), _T("barfoo"), FALSE },
+        { _T("bar$"), _T("barbar"), TRUE },
+        { _T("bar$"), _T("barbar "), FALSE },
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(regExMatchTestData); n++ )
+    {
+        const RegExMatchTestData& data = regExMatchTestData[n];
+
+        wxRegEx re(data.pattern);
+        bool ok = re.Matches(data.text);
+
+        wxPrintf(_T("'%s' %s %s (%s)\n"),
+                 data.pattern,
+                 ok ? _T("matches") : _T("doesn't match"),
+                 data.text,
+                 ok == data.correct ? _T("ok") : _T("ERROR"));
+    }
+}
+
+static void TestRegExSubmatch()
+{
+    wxPuts(_T("*** Testing RE subexpressions ***\n"));
+
+    wxRegEx re(_T("([[:alpha:]]+) ([[:alpha:]]+) ([[:digit:]]+).*([[:digit:]]+)$"));
+    if ( !re.IsValid() )
+    {
+        wxPuts(_T("ERROR: compilation failed."));
+        return;
+    }
+
+    wxString text = _T("Fri Jul 13 18:37:52 CEST 2001");
+
+    if ( !re.Matches(text) )
+    {
+        wxPuts(_T("ERROR: match expected."));
+    }
+    else
+    {
+        wxPrintf(_T("Entire match: %s\n"), re.GetMatch(text).c_str());
+
+        wxPrintf(_T("Date: %s/%s/%s, wday: %s\n"),
+                 re.GetMatch(text, 3).c_str(),
+                 re.GetMatch(text, 2).c_str(),
+                 re.GetMatch(text, 4).c_str(),
+                 re.GetMatch(text, 1).c_str());
+    }
+}
+
+static void TestRegExReplacement()
+{
+    wxPuts(_T("*** Testing RE replacement ***"));
+
+    static struct RegExReplTestData
+    {
+        const wxChar *text;
+        const wxChar *repl;
+        const wxChar *result;
+        size_t count;
+    } regExReplTestData[] =
+    {
+        { _T("foo123"), _T("bar"), _T("bar"), 1 },
+        { _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
+        { _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
+        { _T("123foo"), _T("bar"), _T("123foo"), 0 },
+        { _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
+        { _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
+        { _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
+    };
+
+    const wxChar *pattern = _T("([a-z]+)[^0-9]*([0-9]+)");
+    wxRegEx re = pattern;
+
+    wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern);
+
+    for ( size_t n = 0; n < WXSIZEOF(regExReplTestData); n++ )
+    {
+        const RegExReplTestData& data = regExReplTestData[n];
+
+        wxString text = data.text;
+        size_t nRepl = re.Replace(&text, data.repl);
+
+        wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
+                 data.text, data.repl,
+                 nRepl, nRepl == 1 ? _T("") : _T("es"),
+                 text.c_str());
+        if ( text == data.result && nRepl == data.count )
+        {
+            wxPuts(_T("ok)"));
+        }
+        else
+        {
+            wxPrintf(_T("ERROR: should be %u and '%s')\n"),
+                     data.count, data.result);
+        }
+    }
+}
+
+static void TestRegExInteractive()
+{
+    wxPuts(_T("*** Testing RE interactively ***"));
+
+    for ( ;; )
+    {
+        char pattern[128];
+        printf("\nEnter a pattern: ");
+        if ( !fgets(pattern, WXSIZEOF(pattern), stdin) )
+            break;
+
+        // kill the last '\n'
+        pattern[strlen(pattern) - 1] = 0;
+
+        wxRegEx re;
+        if ( !re.Compile(pattern) )
+        {
+            continue;
+        }
+
+        char text[128];
+        for ( ;; )
+        {
+            printf("Enter text to match: ");
+            if ( !fgets(text, WXSIZEOF(text), stdin) )
+                break;
+
+            // kill the last '\n'
+            text[strlen(text) - 1] = 0;
+
+            if ( !re.Matches(text) )
+            {
+                printf("No match.\n");
+            }
+            else
+            {
+                printf("Pattern matches at '%s'\n", re.GetMatch(text).c_str());
+
+                size_t start, len;
+                for ( size_t n = 1; ; n++ )
+                {
+                    if ( !re.GetMatch(&start, &len, n) )
+                    {
+                        break;
+                    }
+
+                    printf("Subexpr %u matched '%s'\n",
+                           n, wxString(text + start, len).c_str());
+                }
+            }
+        }
+    }
+}
+
+#endif // TEST_REGEX
+
 // ----------------------------------------------------------------------------
 // registry and related stuff
 // ----------------------------------------------------------------------------
@@ -1611,8 +2187,8 @@ static void TestPathList()
 
 #ifdef TEST_REGCONF
 
-#include <wx/confbase.h>
-#include <wx/msw/regconf.h>
+#include "wx/confbase.h"
+#include "wx/msw/regconf.h"
 
 static void TestRegConfWrite()
 {
@@ -1624,7 +2200,7 @@ static void TestRegConfWrite()
 
 #ifdef TEST_REGISTRY
 
-#include <wx/msw/registry.h>
+#include "wx/msw/registry.h"
 
 // I chose this one because I liked its name, but it probably only exists under
 // NT
@@ -1733,9 +2309,9 @@ static void TestRegistryAssociation()
 
 #ifdef TEST_SOCKETS
 
-#include <wx/socket.h>
-#include <wx/protocol/protocol.h>
-#include <wx/protocol/http.h>
+#include "wx/socket.h"
+#include "wx/protocol/protocol.h"
+#include "wx/protocol/http.h"
 
 static void TestSocketServer()
 {
@@ -1865,7 +2441,7 @@ static void TestSocketClient()
 
 #ifdef TEST_FTP
 
-#include <wx/protocol/ftp.h>
+#include "wx/protocol/ftp.h"
 
 static wxFTP ftp;
 
@@ -2189,8 +2765,8 @@ static void TestFtpUpload()
 
 #ifdef TEST_STREAMS
 
-#include <wx/wfstream.h>
-#include <wx/mstream.h>
+#include "wx/wfstream.h"
+#include "wx/mstream.h"
 
 static void TestFileStream()
 {
@@ -2242,8 +2818,8 @@ static void TestMemoryStream()
 
 #ifdef TEST_TIMER
 
-#include <wx/timer.h>
-#include <wx/utils.h>
+#include "wx/timer.h"
+#include "wx/utils.h"
 
 static void TestStopWatch()
 {
@@ -2292,7 +2868,7 @@ static void TestStopWatch()
 
 #ifdef TEST_VCARD
 
-#include <wx/vcard.h>
+#include "wx/vcard.h"
 
 static void DumpVObject(size_t level, const wxVCardObject& vcard)
 {
@@ -2534,10 +3110,10 @@ static void TestVCardWrite()
 
 #ifdef TEST_WCHAR
 
-#include <wx/strconv.h>
-#include <wx/fontenc.h>
-#include <wx/encconv.h>
-#include <wx/buffer.h>
+#include "wx/strconv.h"
+#include "wx/fontenc.h"
+#include "wx/encconv.h"
+#include "wx/buffer.h"
 
 static void TestUtf8()
 {
@@ -2673,8 +3249,8 @@ static void TestZipFileSystem()
 
 #ifdef TEST_ZLIB
 
-#include <wx/zstream.h>
-#include <wx/wfstream.h>
+#include "wx/zstream.h"
+#include "wx/wfstream.h"
 
 static const wxChar *FILENAME_GZ = _T("test.gz");
 static const char *TEST_DATA = "hello and hello again";
@@ -2725,9 +3301,10 @@ static void TestZlibStreamRead()
 
 #ifdef TEST_DATETIME
 
-#include <wx/date.h>
+#include <math.h>
 
-#include <wx/datetime.h>
+#include "wx/date.h"
+#include "wx/datetime.h"
 
 // the test data
 struct Date
@@ -3704,6 +4281,7 @@ static void TestTimeSpanFormat()
         _T("(with ms) %H:%M:%S:%l"),
         _T("100%% of minutes is %M"),       // test "%%"
         _T("%D days and %H hours"),
+        _T("or also %S seconds"),
     };
 
     wxTimeSpan ts1(1, 2, 3, 4),
@@ -3758,7 +4336,7 @@ static void TestTimeCompatibility()
 
 #ifdef TEST_THREADS
 
-#include <wx/thread.h>
+#include "wx/thread.h"
 
 static size_t gs_counter = (size_t)-1;
 static wxCriticalSection gs_critsect;
@@ -4440,6 +5018,44 @@ static void TestStringReplace()
     puts("");
 }
 
+static void TestStringMatch()
+{
+    wxPuts(_T("*** Testing wxString::Matches() ***"));
+
+    static const struct StringMatchTestData
+    {
+        const wxChar *text;
+        const wxChar *wildcard;
+        bool matches;
+    } stringMatchTestData[] =
+    {
+        { _T("foobar"), _T("foo*"), 1 },
+        { _T("foobar"), _T("*oo*"), 1 },
+        { _T("foobar"), _T("*bar"), 1 },
+        { _T("foobar"), _T("??????"), 1 },
+        { _T("foobar"), _T("f??b*"), 1 },
+        { _T("foobar"), _T("f?b*"), 0 },
+        { _T("foobar"), _T("*goo*"), 0 },
+        { _T("foobar"), _T("*foo"), 0 },
+        { _T("foobarfoo"), _T("*foo"), 1 },
+        { _T(""), _T("*"), 1 },
+        { _T(""), _T("?"), 0 },
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(stringMatchTestData); n++ )
+    {
+        const StringMatchTestData& data = stringMatchTestData[n];
+        bool matches = wxString(data.text).Matches(data.wildcard);
+        wxPrintf(_T("'%s' %s '%s' (%s)\n"),
+                 data.wildcard,
+                 matches ? _T("matches") : _T("doesn't match"),
+                 data.text,
+                 matches == data.matches ? _T("ok") : _T("ERROR"));
+    }
+
+    wxPuts(_T(""));
+}
+
 #endif // TEST_STRINGS
 
 // ----------------------------------------------------------------------------
@@ -4448,26 +5064,56 @@ static void TestStringReplace()
 
 int main(int argc, char **argv)
 {
-    if ( !wxInitialize() )
+    wxInitializer initializer;
+    if ( !initializer )
     {
         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
+
+        return -1;
     }
 
-#ifdef TEST_USLEEP
-    puts("Sleeping for 3 seconds... z-z-z-z-z...");
-    wxUsleep(3000);
-#endif // TEST_USLEEP
+#ifdef TEST_SNGLINST
+    wxSingleInstanceChecker checker;
+    if ( checker.Create(_T(".wxconsole.lock")) )
+    {
+        if ( checker.IsAnotherRunning() )
+        {
+            wxPrintf(_T("Another instance of the program is running, exiting.\n"));
+
+            return 1;
+        }
+
+        // wait some time to give time to launch another instance
+        wxPrintf(_T("Press \"Enter\" to continue..."));
+        wxFgetc(stdin);
+    }
+    else // failed to create
+    {
+        wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
+    }
+#endif // TEST_SNGLINST
+
+#ifdef TEST_CHARSET
+    TestCharset();
+#endif // TEST_CHARSET
 
 #ifdef TEST_CMDLINE
+    TestCmdLineConvert();
+
+#if wxUSE_CMDLINE_PARSER
     static const wxCmdLineEntryDesc cmdLineDesc[] =
     {
+        { wxCMD_LINE_SWITCH, _T("h"), _T("help"), "show this help message",
+            wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
         { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
         { wxCMD_LINE_SWITCH, "q", "quiet",   "be quiet" },
 
         { wxCMD_LINE_OPTION, "o", "output",  "output file" },
         { wxCMD_LINE_OPTION, "i", "input",   "input dir" },
-        { wxCMD_LINE_OPTION, "s", "size",    "output block size", wxCMD_LINE_VAL_NUMBER },
-        { wxCMD_LINE_OPTION, "d", "date",    "output file date", wxCMD_LINE_VAL_DATE },
+        { wxCMD_LINE_OPTION, "s", "size",    "output block size",
+            wxCMD_LINE_VAL_NUMBER },
+        { wxCMD_LINE_OPTION, "d", "date",    "output file date",
+            wxCMD_LINE_VAL_DATE },
 
         { wxCMD_LINE_PARAM,  NULL, NULL, "input file",
             wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
@@ -4495,6 +5141,8 @@ int main(int argc, char **argv)
             wxLogMessage("Syntax error detected, aborting.");
             break;
     }
+#endif // wxUSE_CMDLINE_PARSER
+
 #endif // TEST_CMDLINE
 
 #ifdef TEST_STRINGS
@@ -4502,16 +5150,14 @@ int main(int argc, char **argv)
     {
         TestPChar();
         TestString();
-    }
         TestStringSub();
-    if ( 0 )
-    {
         TestStringConstruction();
         TestStringFormat();
         TestStringFind();
         TestStringTokenizer();
         TestStringReplace();
     }
+    TestStringMatch();
 #endif // TEST_STRINGS
 
 #ifdef TEST_ARRAYS
@@ -4565,7 +5211,9 @@ int main(int argc, char **argv)
 #endif // TEST_ARRAYS
 
 #ifdef TEST_DIR
-    TestDirEnum();
+    if ( 0 )
+        TestDirEnum();
+    TestDirTraverse();
 #endif // TEST_DIR
 
 #ifdef TEST_DLLLOADER
@@ -4621,16 +5269,52 @@ int main(int argc, char **argv)
 #endif // TEST_FILE
 
 #ifdef TEST_FILENAME
-    TestFileNameSplit();
     if ( 0 )
     {
-        TestFileNameConstruction();
+        wxFileName fn;
+        fn.Assign("c:\\foo", "bar.baz");
+
+        DumpFileName(fn);
+    }
+
+    TestFileNameMakeRelative();
+    if ( 0 )
+    {
+    TestFileNameConstruction();
+    TestFileNameSplit();
+    TestFileNameTemp();
         TestFileNameCwd();
         TestFileNameComparison();
         TestFileNameOperations();
     }
 #endif // TEST_FILENAME
 
+#ifdef TEST_FILETIME
+    TestFileGetTimes();
+    TestFileSetTimes();
+#endif // TEST_FILETIME
+
+#ifdef TEST_FTP
+    wxLog::AddTraceMask(FTP_TRACE_MASK);
+    if ( TestFtpConnect() )
+    {
+            TestFtpFileSize();
+        if ( 0 )
+        {
+            TestFtpList();
+            TestFtpDownload();
+            TestFtpMisc();
+            TestFtpUpload();
+        }
+        if ( 0 )
+        TestFtpInteractive();
+    }
+    //else: connecting to the FTP server failed
+
+    if ( 0 )
+        TestFtpWuFtpd();
+#endif // TEST_FTP
+
 #ifdef TEST_THREADS
     int nCPUs = wxThread::GetCPUCount();
     printf("This system has %d CPUs\n", nCPUs);
@@ -4666,8 +5350,9 @@ int main(int argc, char **argv)
         TestAddition();
         TestLongLongConversion();
         TestBitOperations();
+        TestLongLongComparison();
     }
-    TestLongLongComparison();
+    TestLongLongPrint();
 #endif // TEST_LONGLONG
 
 #ifdef TEST_HASH
@@ -4687,8 +5372,12 @@ int main(int argc, char **argv)
 #endif // TEST_MIME
 
 #ifdef TEST_INFO_FUNCTIONS
-    TestOsInfo();
-    TestUserInfo();
+    TestDiskInfo();
+    if ( 0 )
+    {
+        TestOsInfo();
+        TestUserInfo();
+    }
 #endif // TEST_INFO_FUNCTIONS
 
 #ifdef TEST_PATHLIST
@@ -4699,6 +5388,18 @@ int main(int argc, char **argv)
     TestRegConfWrite();
 #endif // TEST_REGCONF
 
+#ifdef TEST_REGEX
+    // TODO: write a real test using src/regex/tests file
+    if ( 0 )
+    {
+        TestRegExCompile();
+        TestRegExMatch();
+        TestRegExSubmatch();
+        TestRegExInteractive();
+    }
+    TestRegExReplacement();
+#endif // TEST_REGEX
+
 #ifdef TEST_REGISTRY
     if ( 0 )
         TestRegistryRead();
@@ -4713,27 +5414,6 @@ int main(int argc, char **argv)
         TestSocketClient();
 #endif // TEST_SOCKETS
 
-#ifdef TEST_FTP
-    wxLog::AddTraceMask(FTP_TRACE_MASK);
-    if ( TestFtpConnect() )
-    {
-            TestFtpFileSize();
-        if ( 0 )
-        {
-            TestFtpList();
-            TestFtpDownload();
-            TestFtpMisc();
-            TestFtpUpload();
-        }
-        if ( 0 )
-        TestFtpInteractive();
-    }
-    //else: connecting to the FTP server failed
-
-    if ( 0 )
-        TestFtpWuFtpd();
-#endif // TEST_FTP
-
 #ifdef TEST_STREAMS
     if ( 0 )
     TestFileStream();
@@ -4769,6 +5449,11 @@ int main(int argc, char **argv)
         TestDateTimeInteractive();
 #endif // TEST_DATETIME
 
+#ifdef TEST_USLEEP
+    puts("Sleeping for 3 seconds... z-z-z-z-z...");
+    wxUsleep(3000);
+#endif // TEST_USLEEP
+
 #ifdef TEST_VCARD
     if ( 0 )
     TestVCardRead();
@@ -4791,8 +5476,6 @@ int main(int argc, char **argv)
     TestZlibStreamRead();
 #endif // TEST_ZLIB
 
-    wxUninitialize();
-
     return 0;
 }