updated opengl

[wxWidgets.git] / samples / console / console.cpp

diff --git a/samples/console/console.cpp b/samples/console/console.cpp
index 5adda86c6c9528e73dc0bf7d2209af8c38636eb3..12d8911e08e4fcf2c0d7737b89b17d6e0c55df56 100644 (file)
--- a/samples/console/console.cpp
+++ b/samples/console/console.cpp
@@ -36,19 +36,26 @@
 // what to test (in alphabetic order)?
 
 //#define TEST_ARRAYS
 // what to test (in alphabetic order)?
 
 //#define TEST_ARRAYS

+#define TEST_CHARSET

 //#define TEST_CMDLINE
 //#define TEST_DATETIME
 //#define TEST_DIR
 //#define TEST_DLLLOADER
 //#define TEST_CMDLINE
 //#define TEST_DATETIME
 //#define TEST_DIR
 //#define TEST_DLLLOADER

-#define TEST_EXECUTE
+//#define TEST_ENVIRON
+//#define TEST_EXECUTE

 //#define TEST_FILE
 //#define TEST_FILECONF
 //#define TEST_FILE
 //#define TEST_FILECONF

+//#define TEST_FILENAME
+//#define TEST_FTP

 //#define TEST_HASH
 //#define TEST_HASH

+//#define TEST_INFO_FUNCTIONS

 //#define TEST_LIST
 //#define TEST_LIST

+//#define TEST_LOCALE

 //#define TEST_LOG
 //#define TEST_LONGLONG
 //#define TEST_MIME
 //#define TEST_LOG
 //#define TEST_LONGLONG
 //#define TEST_MIME

-//#define TEST_INFO_FUNCTIONS
+//#define TEST_PATHLIST
+//#define TEST_REGCONF

 //#define TEST_REGISTRY
 //#define TEST_SOCKETS
 //#define TEST_STREAMS
 //#define TEST_REGISTRY
 //#define TEST_SOCKETS
 //#define TEST_STREAMS


@@ -109,6 +116,46 @@ static wxString MakePrintable(const wxChar *s)
 
 #endif // MakePrintable() is used
 
 
 #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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxCmdLineParser
 // ----------------------------------------------------------------------------


@@ -283,6 +330,43 @@ static void TestDllLoad()
 
 #endif // TEST_DLLLOADER
 
 
 #endif // TEST_DLLLOADER
 

+// ----------------------------------------------------------------------------
+// wxGet/SetEnv
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_ENVIRON
+
+#include <wx/utils.h>
+
+static wxString MyGetEnv(const wxString& var)
+{
+    wxString val;
+    if ( !wxGetEnv(var, &val) )
+        val = _T("<empty>");
+    else
+        val = wxString(_T('\'')) + val + _T('\'');
+
+    return val;
+}
+
+static void TestEnvironment()
+{
+    const wxChar *var = _T("wxTestVar");
+
+    puts("*** testing environment access functions ***");
+
+    printf("Initially getenv(%s) = %s\n", var, MyGetEnv(var).c_str());
+    wxSetEnv(var, _T("value for wxTestVar"));
+    printf("After wxSetEnv: getenv(%s) = %s\n",  var, MyGetEnv(var).c_str());
+    wxSetEnv(var, _T("another value"));
+    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")));
+}
+
+#endif // TEST_ENVIRON
+

 // ----------------------------------------------------------------------------
 // wxExecute
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxExecute
 // ----------------------------------------------------------------------------


@@ -357,6 +441,7 @@ static void TestExecute()
 #ifdef TEST_FILE
 
 #include <wx/file.h>
 #ifdef TEST_FILE
 
 #include <wx/file.h>

+#include <wx/ffile.h>

 #include <wx/textfile.h>
 
 static void TestFileRead()
 #include <wx/textfile.h>
 
 static void TestFileRead()


@@ -433,6 +518,55 @@ static void TestTextFileRead()
     puts("");
 }
 
     puts("");
 }
 

+static void TestFileCopy()
+{
+    puts("*** Testing wxCopyFile ***");
+
+    static const wxChar *filename1 = _T("testdata.fc");
+    static const wxChar *filename2 = _T("test2");
+    if ( !wxCopyFile(filename1, filename2) )
+    {
+        puts("ERROR: failed to copy file");
+    }
+    else
+    {
+        wxFFile f1(filename1, "rb"),
+                f2(filename2, "rb");
+
+        if ( !f1.IsOpened() || !f2.IsOpened() )
+        {
+            puts("ERROR: failed to open file(s)");
+        }
+        else
+        {
+            wxString s1, s2;
+            if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
+            {
+                puts("ERROR: failed to read file(s)");
+            }
+            else
+            {
+                if ( (s1.length() != s2.length()) ||
+                     (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
+                {
+                    puts("ERROR: copy error!");
+                }
+                else
+                {
+                    puts("File was copied ok.");
+                }
+            }
+        }
+    }
+
+    if ( !wxRemoveFile(filename2) )
+    {
+        puts("ERROR: failed to remove the file");
+    }
+
+    puts("");
+}
+

 #endif // TEST_FILE
 
 // ----------------------------------------------------------------------------
 #endif // TEST_FILE
 
 // ----------------------------------------------------------------------------


@@ -498,6 +632,95 @@ static void TestFileConfRead()
 
 #endif // TEST_FILECONF
 
 
 #endif // TEST_FILECONF
 

+// ----------------------------------------------------------------------------
+// wxFileName
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_FILENAME
+
+#include <wx/filename.h>
+
+static struct FileNameInfo
+{
+    const wxChar *fullname;
+    const wxChar *path;
+    const wxChar *name;
+    const wxChar *ext;
+} 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") },
+};
+
+static void TestFileNameConstruction()
+{
+    puts("*** testing wxFileName construction ***");
+
+    for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
+    {
+        wxFileName fn(filenames[n].fullname, wxPATH_UNIX);
+
+        printf("Filename: '%s'\t", fn.GetFullPath().c_str());
+        if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), wxPATH_UNIX) )
+        {
+            puts("ERROR (couldn't be normalized)");
+        }
+        else
+        {
+            printf("normalized: '%s'\n", fn.GetFullPath().c_str());
+        }
+    }
+
+    puts("");
+}
+
+static void TestFileNameSplit()
+{
+    puts("*** testing wxFileName splitting ***");
+
+    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);
+
+        printf("%s -> path = '%s', name = '%s', ext = '%s'",
+               fni.fullname, path.c_str(), name.c_str(), ext.c_str());
+        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 TestFileNameComparison()
+{
+    // TODO!
+}
+
+static void TestFileNameOperations()
+{
+    // TODO!
+}
+
+static void TestFileNameCwd()
+{
+    // TODO!
+}
+
+#endif // TEST_FILENAME
+

 // ----------------------------------------------------------------------------
 // wxHashTable
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxHashTable
 // ----------------------------------------------------------------------------


@@ -622,6 +845,293 @@ static void TestListCtor()
 
 #endif // TEST_LIST
 
 
 #endif // TEST_LIST
 

+// ----------------------------------------------------------------------------
+// wxLocale
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_LOCALE
+
+#include "wx/intl.h"
+#include "wx/utils.h"   // for wxSetEnv
+
+static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
+
+// find the name of the language from its value
+static const char *GetLangName(int lang)
+{
+    static const char *languageNames[] =
+    {
+        "DEFAULT", 
+        "UNKNOWN", 
+        "ABKHAZIAN",
+        "AFAR",
+        "AFRIKAANS",
+        "ALBANIAN",
+        "AMHARIC",
+        "ARABIC",
+        "ARABIC_ALGERIA",
+        "ARABIC_BAHRAIN",
+        "ARABIC_EGYPT",
+        "ARABIC_IRAQ",
+        "ARABIC_JORDAN",
+        "ARABIC_KUWAIT",
+        "ARABIC_LEBANON",
+        "ARABIC_LIBYA",
+        "ARABIC_MOROCCO",
+        "ARABIC_OMAN",
+        "ARABIC_QATAR",
+        "ARABIC_SAUDI_ARABIA",
+        "ARABIC_SUDAN",
+        "ARABIC_SYRIA",
+        "ARABIC_TUNISIA",
+        "ARABIC_UAE",
+        "ARABIC_YEMEN",
+        "ARMENIAN",
+        "ASSAMESE",
+        "AYMARA",
+        "AZERI",
+        "AZERI_CYRILLIC",
+        "AZERI_LATIN",
+        "BASHKIR",
+        "BASQUE",
+        "BELARUSIAN",
+        "BENGALI",
+        "BHUTANI",
+        "BIHARI",
+        "BISLAMA",
+        "BRETON",
+        "BULGARIAN",
+        "BURMESE",
+        "CAMBODIAN",
+        "CATALAN",
+        "CHINESE",
+        "CHINESE_SIMPLIFIED",
+        "CHINESE_TRADITIONAL",
+        "CHINESE_HONGKONG",
+        "CHINESE_MACAU",
+        "CHINESE_SINGAPORE",
+        "CHINESE_TAIWAN",
+        "CORSICAN",
+        "CROATIAN",
+        "CZECH",
+        "DANISH",
+        "DUTCH",
+        "DUTCH_BELGIAN",
+        "ENGLISH",
+        "ENGLISH_UK",
+        "ENGLISH_US",
+        "ENGLISH_AUSTRALIA",
+        "ENGLISH_BELIZE",
+        "ENGLISH_BOTSWANA",
+        "ENGLISH_CANADA",
+        "ENGLISH_CARIBBEAN",
+        "ENGLISH_DENMARK",
+        "ENGLISH_EIRE",
+        "ENGLISH_JAMAICA",
+        "ENGLISH_NEW_ZEALAND",
+        "ENGLISH_PHILIPPINES",
+        "ENGLISH_SOUTH_AFRICA",
+        "ENGLISH_TRINIDAD",
+        "ENGLISH_ZIMBABWE",
+        "ESPERANTO",
+        "ESTONIAN",
+        "FAEROESE",
+        "FARSI",
+        "FIJI",
+        "FINNISH",
+        "FRENCH",
+        "FRENCH_BELGIAN",
+        "FRENCH_CANADIAN",
+        "FRENCH_LUXEMBOURG",
+        "FRENCH_MONACO",
+        "FRENCH_SWISS",
+        "FRISIAN",
+        "GALICIAN",
+        "GEORGIAN",
+        "GERMAN",
+        "GERMAN_AUSTRIAN",
+        "GERMAN_BELGIUM",
+        "GERMAN_LIECHTENSTEIN",
+        "GERMAN_LUXEMBOURG",
+        "GERMAN_SWISS",
+        "GREEK",
+        "GREENLANDIC",
+        "GUARANI",
+        "GUJARATI",
+        "HAUSA",
+        "HEBREW",
+        "HINDI",
+        "HUNGARIAN",
+        "ICELANDIC",
+        "INDONESIAN",
+        "INTERLINGUA",
+        "INTERLINGUE",
+        "INUKTITUT",
+        "INUPIAK",
+        "IRISH",
+        "ITALIAN",
+        "ITALIAN_SWISS",
+        "JAPANESE",
+        "JAVANESE",
+        "KANNADA",
+        "KASHMIRI",
+        "KASHMIRI_INDIA",
+        "KAZAKH",
+        "KERNEWEK",
+        "KINYARWANDA",
+        "KIRGHIZ",
+        "KIRUNDI",
+        "KONKANI",
+        "KOREAN",
+        "KURDISH",
+        "LAOTHIAN",
+        "LATIN",
+        "LATVIAN",
+        "LINGALA",
+        "LITHUANIAN",
+        "MACEDONIAN",
+        "MALAGASY",
+        "MALAY",
+        "MALAYALAM",
+        "MALAY_BRUNEI_DARUSSALAM",
+        "MALAY_MALAYSIA",
+        "MALTESE",
+        "MANIPURI",
+        "MAORI",
+        "MARATHI",
+        "MOLDAVIAN",
+        "MONGOLIAN",
+        "NAURU",
+        "NEPALI",
+        "NEPALI_INDIA",
+        "NORWEGIAN_BOKMAL",
+        "NORWEGIAN_NYNORSK",
+        "OCCITAN",
+        "ORIYA",
+        "OROMO",
+        "PASHTO",
+        "POLISH",
+        "PORTUGUESE",
+        "PORTUGUESE_BRAZILIAN",
+        "PUNJABI",
+        "QUECHUA",
+        "RHAETO_ROMANCE",
+        "ROMANIAN",
+        "RUSSIAN",
+        "RUSSIAN_UKRAINE",
+        "SAMOAN",
+        "SANGHO",
+        "SANSKRIT",
+        "SCOTS_GAELIC",
+        "SERBIAN",
+        "SERBIAN_CYRILLIC",
+        "SERBIAN_LATIN",
+        "SERBO_CROATIAN",
+        "SESOTHO",
+        "SETSWANA",
+        "SHONA",
+        "SINDHI",
+        "SINHALESE",
+        "SISWATI",
+        "SLOVAK",
+        "SLOVENIAN",
+        "SOMALI",
+        "SPANISH",
+        "SPANISH_ARGENTINA",
+        "SPANISH_BOLIVIA",
+        "SPANISH_CHILE",
+        "SPANISH_COLOMBIA",
+        "SPANISH_COSTA_RICA",
+        "SPANISH_DOMINICAN_REPUBLIC",
+        "SPANISH_ECUADOR",
+        "SPANISH_EL_SALVADOR",
+        "SPANISH_GUATEMALA",
+        "SPANISH_HONDURAS",
+        "SPANISH_MEXICAN",
+        "SPANISH_MODERN",
+        "SPANISH_NICARAGUA",
+        "SPANISH_PANAMA",
+        "SPANISH_PARAGUAY",
+        "SPANISH_PERU",
+        "SPANISH_PUERTO_RICO",
+        "SPANISH_URUGUAY",
+        "SPANISH_US",
+        "SPANISH_VENEZUELA",
+        "SUNDANESE",
+        "SWAHILI",
+        "SWEDISH",
+        "SWEDISH_FINLAND",
+        "TAGALOG",
+        "TAJIK",
+        "TAMIL",
+        "TATAR",
+        "TELUGU",
+        "THAI",
+        "TIBETAN",
+        "TIGRINYA",
+        "TONGA",
+        "TSONGA",
+        "TURKISH",
+        "TURKMEN",
+        "TWI",
+        "UIGHUR",
+        "UKRAINIAN",
+        "URDU",
+        "URDU_INDIA",
+        "URDU_PAKISTAN",
+        "UZBEK",
+        "UZBEK_CYRILLIC",
+        "UZBEK_LATIN",
+        "VIETNAMESE",
+        "VOLAPUK",
+        "WELSH",
+        "WOLOF",
+        "XHOSA",
+        "YIDDISH",
+        "YORUBA",
+        "ZHUANG",
+        "ZULU",
+    };
+
+    if ( (size_t)lang < WXSIZEOF(languageNames) )
+        return languageNames[lang];
+    else
+        return "INVALID";
+}
+
+static void TestDefaultLang()
+{
+    puts("*** Testing wxLocale::GetSystemLanguage ***");
+
+    static const wxChar *langStrings[] =
+    {
+        NULL,               // system default
+        _T("C"),
+        _T("fr"),
+        _T("fr_FR"),
+        _T("en"),
+        _T("en_GB"),
+        _T("en_US"),
+        _T("de_DE.iso88591"),
+        _T("german"),
+        _T("?"),            // invalid lang spec
+        _T("klingonese"),   // I bet on some systems it does exist...
+    };
+
+    for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
+    {
+        const char *langStr = langStrings[n];
+        if ( langStr )
+            wxSetEnv(_T("LC_ALL"), langStr);
+
+        int lang = gs_localeDefault.GetSystemLanguage();
+        printf("Locale for '%s' is %s.\n",
+               langStr ? langStr : "system default", GetLangName(lang));
+    }
+}
+
+#endif // TEST_LOCALE
+

 // ----------------------------------------------------------------------------
 // MIME types
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // MIME types
 // ----------------------------------------------------------------------------


@@ -630,13 +1140,13 @@ static void TestListCtor()
 
 #include <wx/mimetype.h>
 
 
 #include <wx/mimetype.h>
 

-static wxMimeTypesManager g_mimeManager;
-

 static void TestMimeEnum()
 {
 static void TestMimeEnum()
 {

+    wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
+

     wxArrayString mimetypes;
 
     wxArrayString mimetypes;
 

-    size_t count = g_mimeManager.EnumAllFileTypes(mimetypes);
+    size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);

 
     printf("*** All %u known filetypes: ***\n", count);
 
 
     printf("*** All %u known filetypes: ***\n", count);
 


@@ -645,7 +1155,8 @@ static void TestMimeEnum()
 
     for ( size_t n = 0; n < count; n++ )
     {
 
     for ( size_t n = 0; n < count; n++ )
     {

-        wxFileType *filetype = g_mimeManager.GetFileTypeFromMimeType(mimetypes[n]);
+        wxFileType *filetype =
+            wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);

         if ( !filetype )
         {
             printf("nothing known about the filetype '%s'!\n",
         if ( !filetype )
         {
             printf("nothing known about the filetype '%s'!\n",


@@ -669,21 +1180,34 @@ static void TestMimeEnum()
         printf("\t%s: %s (%s)\n",
                mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
     }
         printf("\t%s: %s (%s)\n",
                mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
     }

+
+    puts("");

 }
 
 static void TestMimeOverride()
 {
     wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
 
 }
 
 static void TestMimeOverride()
 {
     wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
 

-    wxString mailcap = _T("/tmp/mailcap"),
-             mimetypes = _T("/tmp/mime.types");
+    static const wxChar *mailcap = _T("/tmp/mailcap");
+    static const wxChar *mimetypes = _T("/tmp/mime.types");
+
+    if ( wxFile::Exists(mailcap) )
+        wxPrintf(_T("Loading mailcap from '%s': %s\n"),
+                 mailcap,
+                 wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
+    else
+        wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
+                 mailcap);
+
+    if ( wxFile::Exists(mimetypes) )
+        wxPrintf(_T("Loading mime.types from '%s': %s\n"),
+                 mimetypes,
+                 wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
+    else
+        wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
+                 mimetypes);

 
 

-    wxPrintf(_T("Loading mailcap from '%s': %s\n"),
-             mailcap.c_str(),
-             g_mimeManager.ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
-    wxPrintf(_T("Loading mime.types from '%s': %s\n"),
-             mimetypes.c_str(),
-             g_mimeManager.ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
+    puts("");

 }
 
 static void TestMimeFilename()
 }
 
 static void TestMimeFilename()


@@ -701,7 +1225,7 @@ static void TestMimeFilename()
     {
         const wxString fname = filenames[n];
         wxString ext = fname.AfterLast(_T('.'));
     {
         const wxString fname = filenames[n];
         wxString ext = fname.AfterLast(_T('.'));

-        wxFileType *ft = g_mimeManager.GetFileTypeFromExtension(ext);
+        wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);

         if ( !ft )
         {
             wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
         if ( !ft )
         {
             wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());


@@ -723,6 +1247,36 @@ static void TestMimeFilename()
             delete ft;
         }
     }
             delete ft;
         }
     }

+
+    puts("");
+}
+
+static void TestMimeAssociate()
+{
+    wxPuts(_T("*** Testing creation of filetype association ***\n"));
+
+    wxFileTypeInfo ftInfo(
+                            _T("application/x-xyz"),
+                            _T("xyzview '%s'"), // open cmd
+                            _T(""),             // print cmd
+                            _T("XYZ File")  // description
+                            _T(".xyz"),     // extensions
+                            NULL            // end of extensions
+                         );
+    ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
+
+    wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
+    if ( !ft )
+    {
+        wxPuts(_T("ERROR: failed to create association!"));
+    }
+    else
+    {
+        // TODO: read it back
+        delete ft;
+    }
+
+    puts("");

 }
 
 #endif // TEST_MIME
 }
 
 #endif // TEST_MIME


@@ -1056,14 +1610,53 @@ static void TestLongLongComparison()
 #endif // TEST_LONGLONG
 
 // ----------------------------------------------------------------------------
 #endif // TEST_LONGLONG
 
 // ----------------------------------------------------------------------------

-// registry
+// path list
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_PATHLIST
+
+static void TestPathList()
+{
+    puts("*** Testing wxPathList ***\n");
+
+    wxPathList pathlist;
+    pathlist.AddEnvList("PATH");
+    wxString path = pathlist.FindValidPath("ls");
+    if ( path.empty() )
+    {
+        printf("ERROR: command not found in the path.\n");
+    }
+    else
+    {
+        printf("Command found in the path as '%s'.\n", path.c_str());
+    }
+}
+
+#endif // TEST_PATHLIST
+
+// ----------------------------------------------------------------------------
+// registry and related stuff

 // ----------------------------------------------------------------------------
 
 // this is for MSW only
 #ifndef __WXMSW__
 // ----------------------------------------------------------------------------
 
 // this is for MSW only
 #ifndef __WXMSW__

+    #undef TEST_REGCONF

     #undef TEST_REGISTRY
 #endif
 
     #undef TEST_REGISTRY
 #endif
 

+#ifdef TEST_REGCONF
+
+#include <wx/confbase.h>
+#include <wx/msw/regconf.h>
+
+static void TestRegConfWrite()
+{
+    wxRegConfig regconf(_T("console"), _T("wxwindows"));
+    regconf.Write(_T("Hello"), wxString(_T("world")));
+}
+
+#endif // TEST_REGCONF
+

 #ifdef TEST_REGISTRY
 
 #include <wx/msw/registry.h>
 #ifdef TEST_REGISTRY
 
 #include <wx/msw/registry.h>


@@ -1177,7 +1770,6 @@ static void TestRegistryAssociation()
 
 #include <wx/socket.h>
 #include <wx/protocol/protocol.h>
 
 #include <wx/socket.h>
 #include <wx/protocol/protocol.h>

-#include <wx/protocol/ftp.h>

 #include <wx/protocol/http.h>
 
 static void TestSocketServer()
 #include <wx/protocol/http.h>
 
 static void TestSocketServer()


@@ -1300,56 +1892,84 @@ static void TestSocketClient()
     }
 }
 
     }
 }
 

-static void TestProtocolFtp()
-{
-    puts("*** Testing wxFTP download ***\n");
+#endif // TEST_SOCKETS

 
 

-    wxLog::AddTraceMask(_T("ftp"));
+// ----------------------------------------------------------------------------
+// FTP
+// ----------------------------------------------------------------------------

 
 

+#ifdef TEST_FTP
+
+#include <wx/protocol/ftp.h>
+
+static wxFTP ftp;
+
+#define FTP_ANONYMOUS
+
+#ifdef FTP_ANONYMOUS
+    static const char *directory = "/pub";
+    static const char *filename = "welcome.msg";
+#else
+    static const char *directory = "/etc";
+    static const char *filename = "issue";
+#endif
+
+static bool TestFtpConnect()
+{
+    puts("*** Testing FTP connect ***");
+
+#ifdef FTP_ANONYMOUS

     static const char *hostname = "ftp.wxwindows.org";
 
     static const char *hostname = "ftp.wxwindows.org";
 

-    printf("--- Attempting to connect to %s:21...\n", hostname);
+    printf("--- Attempting to connect to %s:21 anonymously...\n", hostname);
+#else // !FTP_ANONYMOUS
+    static const char *hostname = "localhost";
+
+    char user[256];
+    fgets(user, WXSIZEOF(user), stdin);
+    user[strlen(user) - 1] = '\0'; // chop off '\n'
+    ftp.SetUser(user);
+
+    char password[256];
+    printf("Password for %s: ", password);
+    fgets(password, WXSIZEOF(password), stdin);
+    password[strlen(password) - 1] = '\0'; // chop off '\n'
+    ftp.SetPassword(password);
+
+    printf("--- Attempting to connect to %s:21 as %s...\n", hostname, user);
+#endif // FTP_ANONYMOUS/!FTP_ANONYMOUS

 
 

-    wxFTP ftp;

     if ( !ftp.Connect(hostname) )
     {
         printf("ERROR: failed to connect to %s\n", hostname);
     if ( !ftp.Connect(hostname) )
     {
         printf("ERROR: failed to connect to %s\n", hostname);

+
+        return FALSE;

     }
     else
     {
         printf("--- Connected to %s, current directory is '%s'\n",
                hostname, ftp.Pwd().c_str());
     }
     else
     {
         printf("--- Connected to %s, current directory is '%s'\n",
                hostname, ftp.Pwd().c_str());

-        if ( !ftp.ChDir(_T("pub")) )
-        {
-            puts("ERROR: failed to cd to pub");
-        }
-
-        wxArrayString files;
-        if ( !ftp.GetList(files) )
-        {
-            puts("ERROR: failed to get list of files");
-        }
-        else
-        {
-            printf("List of files under '%s':\n", ftp.Pwd().c_str());
-            size_t count = files.GetCount();
-            for ( size_t n = 0; n < count; n++ )
-            {
-                printf("\t%s\n", files[n].c_str());
-            }
-            puts("End of the file list");
-        }
+    }

 
 

-        if ( !ftp.ChDir(_T("..")) )
-        {
-            puts("ERROR: failed to cd to ..");
-        }
+    return TRUE;
+}

 
 

-        static const char *filename = "welcome.msg";
+// test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
+static void TestFtpWuFtpd()
+{
+    wxFTP ftp;
+    static const char *hostname = "ftp.eudora.com";
+    if ( !ftp.Connect(hostname) )
+    {
+        printf("ERROR: failed to connect to %s\n", hostname);
+    }
+    else
+    {
+        static const char *filename = "eudora/pubs/draft-gellens-submit-09.txt";

         wxInputStream *in = ftp.GetInputStream(filename);
         if ( !in )
         {
         wxInputStream *in = ftp.GetInputStream(filename);
         if ( !in )
         {

-            puts("ERROR: couldn't get input stream");
+            printf("ERROR: couldn't get input stream for %s\n", filename);

         }
         else
         {
         }
         else
         {


@@ -1363,7 +1983,7 @@ static void TestProtocolFtp()
             }
             else
             {
             }
             else
             {

-                printf("\nContents of %s:\n%s\n", filename, data);
+                printf("Successfully retrieved the file.\n");

             }
 
             delete [] data;
             }
 
             delete [] data;


@@ -1372,50 +1992,231 @@ static void TestProtocolFtp()
     }
 }
 
     }
 }
 

-static void TestProtocolFtpUpload()
+static void TestFtpList()

 {
 {

-    puts("*** Testing wxFTP uploading ***\n");
+    puts("*** Testing wxFTP file listing ***\n");
+
+    // test CWD
+    if ( !ftp.ChDir(directory) )
+    {
+        printf("ERROR: failed to cd to %s\n", directory);
+    }

 
 

-    wxLog::AddTraceMask(_T("ftp"));
+    printf("Current directory is '%s'\n", ftp.Pwd().c_str());

 
 

-    static const char *hostname = "localhost";
+    // test NLIST and LIST
+    wxArrayString files;
+    if ( !ftp.GetFilesList(files) )
+    {
+        puts("ERROR: failed to get NLIST of files");
+    }
+    else
+    {
+        printf("Brief list of files under '%s':\n", ftp.Pwd().c_str());
+        size_t count = files.GetCount();
+        for ( size_t n = 0; n < count; n++ )
+        {
+            printf("\t%s\n", files[n].c_str());
+        }
+        puts("End of the file list");
+    }

 
 

-    printf("--- Attempting to connect to %s:21...\n", hostname);
+    if ( !ftp.GetDirList(files) )
+    {
+        puts("ERROR: failed to get LIST of files");
+    }
+    else
+    {
+        printf("Detailed list of files under '%s':\n", ftp.Pwd().c_str());
+        size_t count = files.GetCount();
+        for ( size_t n = 0; n < count; n++ )
+        {
+            printf("\t%s\n", files[n].c_str());
+        }
+        puts("End of the file list");
+    }

 
 

-    wxFTP ftp;
-    ftp.SetUser("zeitlin");
-    ftp.SetPassword("insert your password here");
-    if ( !ftp.Connect(hostname) )
+    if ( !ftp.ChDir(_T("..")) )

     {
     {

-        printf("ERROR: failed to connect to %s\n", hostname);
+        puts("ERROR: failed to cd to ..");
+    }
+
+    printf("Current directory is '%s'\n", ftp.Pwd().c_str());
+}
+
+static void TestFtpDownload()
+{
+    puts("*** Testing wxFTP download ***\n");
+
+    // test RETR
+    wxInputStream *in = ftp.GetInputStream(filename);
+    if ( !in )
+    {
+        printf("ERROR: couldn't get input stream for %s\n", filename);

     }
     else
     {
     }
     else
     {

-        printf("--- Connected to %s, current directory is '%s'\n",
-               hostname, ftp.Pwd().c_str());
+        size_t size = in->StreamSize();
+        printf("Reading file %s (%u bytes)...", filename, size);
+        fflush(stdout);

 
 

-        // upload a file
-        static const char *file1 = "test1";
-        static const char *file2 = "test2";
-        wxOutputStream *out = ftp.GetOutputStream(file1);
-        if ( out )
+        char *data = new char[size];
+        if ( !in->Read(data, size) )
+        {
+            puts("ERROR: read error");
+        }
+        else

         {
         {

-            printf("--- Uploading to %s ---\n", file1);
-            out->Write("First hello", 11);
-            delete out;
+            printf("\nContents of %s:\n%s\n", filename, data);

         }
 
         }
 

-        out = ftp.GetOutputStream(file2);
-        if ( out )
+        delete [] data;
+        delete in;
+    }
+}
+
+static void TestFtpFileSize()
+{
+    puts("*** Testing FTP SIZE command ***");
+
+    if ( !ftp.ChDir(directory) )
+    {
+        printf("ERROR: failed to cd to %s\n", directory);
+    }
+
+    printf("Current directory is '%s'\n", ftp.Pwd().c_str());
+
+    if ( ftp.FileExists(filename) )
+    {
+        int size = ftp.GetFileSize(filename);
+        if ( size == -1 )
+            printf("ERROR: couldn't get size of '%s'\n", filename);
+        else
+            printf("Size of '%s' is %d bytes.\n", filename, size);
+    }
+    else
+    {
+        printf("ERROR: '%s' doesn't exist\n", filename);
+    }
+}
+
+static void TestFtpMisc()
+{
+    puts("*** Testing miscellaneous wxFTP functions ***");
+
+    if ( ftp.SendCommand("STAT") != '2' )
+    {
+        puts("ERROR: STAT failed");
+    }
+    else
+    {
+        printf("STAT returned:\n\n%s\n", ftp.GetLastResult().c_str());
+    }
+
+    if ( ftp.SendCommand("HELP SITE") != '2' )
+    {
+        puts("ERROR: HELP SITE failed");
+    }
+    else
+    {
+        printf("The list of site-specific commands:\n\n%s\n",
+               ftp.GetLastResult().c_str());
+    }
+}
+
+static void TestFtpInteractive()
+{
+    puts("\n*** Interactive wxFTP test ***");
+
+    char buf[128];
+
+    for ( ;; )
+    {
+        printf("Enter FTP command: ");
+        if ( !fgets(buf, WXSIZEOF(buf), stdin) )
+            break;
+
+        // kill the last '\n'
+        buf[strlen(buf) - 1] = 0;
+
+        // special handling of LIST and NLST as they require data connection
+        wxString start(buf, 4);
+        start.MakeUpper();
+        if ( start == "LIST" || start == "NLST" )
+        {
+            wxString wildcard;
+            if ( strlen(buf) > 4 )
+                wildcard = buf + 5;
+
+            wxArrayString files;
+            if ( !ftp.GetList(files, wildcard, start == "LIST") )
+            {
+                printf("ERROR: failed to get %s of files\n", start.c_str());
+            }
+            else
+            {
+                printf("--- %s of '%s' under '%s':\n",
+                       start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
+                size_t count = files.GetCount();
+                for ( size_t n = 0; n < count; n++ )
+                {
+                    printf("\t%s\n", files[n].c_str());
+                }
+                puts("--- End of the file list");
+            }
+        }
+        else // !list

         {
         {

-            printf("--- Uploading to %s ---\n", file1);
-            out->Write("Second hello", 12);
-            delete out;
+            char ch = ftp.SendCommand(buf);
+            printf("Command %s", ch ? "succeeded" : "failed");
+            if ( ch )
+            {
+                printf(" (return code %c)", ch);
+            }
+
+            printf(", server reply:\n%s\n\n", ftp.GetLastResult().c_str());

         }
     }
         }
     }

+
+    puts("\n*** done ***");

 }
 
 }
 

-#endif // TEST_SOCKETS
+static void TestFtpUpload()
+{
+    puts("*** Testing wxFTP uploading ***\n");
+
+    // upload a file
+    static const char *file1 = "test1";
+    static const char *file2 = "test2";
+    wxOutputStream *out = ftp.GetOutputStream(file1);
+    if ( out )
+    {
+        printf("--- Uploading to %s ---\n", file1);
+        out->Write("First hello", 11);
+        delete out;
+    }
+
+    // send a command to check the remote file
+    if ( ftp.SendCommand(wxString("STAT ") + file1) != '2' )
+    {
+        printf("ERROR: STAT %s failed\n", file1);
+    }
+    else
+    {
+        printf("STAT %s returned:\n\n%s\n",
+               file1, ftp.GetLastResult().c_str());
+    }
+
+    out = ftp.GetOutputStream(file2);
+    if ( out )
+    {
+        printf("--- Uploading to %s ---\n", file1);
+        out->Write("Second hello", 12);
+        delete out;
+    }
+}
+
+#endif // TEST_FTP

 
 // ----------------------------------------------------------------------------
 // streams
 
 // ----------------------------------------------------------------------------
 // streams


@@ -1423,8 +2224,34 @@ static void TestProtocolFtpUpload()
 
 #ifdef TEST_STREAMS
 
 
 #ifdef TEST_STREAMS
 

+#include <wx/wfstream.h>

 #include <wx/mstream.h>
 
 #include <wx/mstream.h>
 

+static void TestFileStream()
+{
+    puts("*** Testing wxFileInputStream ***");
+
+    static const wxChar *filename = _T("testdata.fs");
+    {
+        wxFileOutputStream fsOut(filename);
+        fsOut.Write("foo", 3);
+    }
+
+    wxFileInputStream fsIn(filename);
+    printf("File stream size: %u\n", fsIn.GetSize());
+    while ( !fsIn.Eof() )
+    {
+        putchar(fsIn.GetC());
+    }
+
+    if ( !wxRemoveFile(filename) )
+    {
+        printf("ERROR: failed to remove the file '%s'.\n", filename);
+    }
+
+    puts("\n*** wxFileInputStream test done ***");
+}
+

 static void TestMemoryStream()
 {
     puts("*** Testing wxMemoryInputStream ***");
 static void TestMemoryStream()
 {
     puts("*** Testing wxMemoryInputStream ***");


@@ -1743,37 +2570,49 @@ static void TestVCardWrite()
 #ifdef TEST_WCHAR
 
 #include <wx/strconv.h>
 #ifdef TEST_WCHAR
 
 #include <wx/strconv.h>

+#include <wx/fontenc.h>
+#include <wx/encconv.h>

 #include <wx/buffer.h>
 
 static void TestUtf8()
 {
     puts("*** Testing UTF8 support ***\n");
 
 #include <wx/buffer.h>
 
 static void TestUtf8()
 {
     puts("*** Testing UTF8 support ***\n");
 

-    wxString testString = "français";
-#if 0
-"************ French - Français ****************"
-"Juste un petit exemple pour dire que les français aussi"
-"ont à cœur de pouvoir utiliser tous leurs caractères ! :)";
-#endif
-
-    wxWCharBuffer wchBuf = testString.wc_str(wxConvUTF8);
-    const wchar_t *pwz = (const wchar_t *)wchBuf;
-    wxString testString2(pwz, wxConvLocal);
-
-    printf("Decoding '%s' => '%s'\n", testString.c_str(), testString2.c_str());
+    static const char textInUtf8[] =
+    {
+        208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
+        208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
+        176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
+        208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
+        181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
+        208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
+        178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
+    };

 
 

-    char *psz = "fran" "\xe7" "ais";
-    size_t len = strlen(psz);
-    wchar_t *pwz2 = new wchar_t[len + 1];
-    for ( size_t n = 0; n <= len; n++ )
+    char buf[1024];
+    wchar_t wbuf[1024];
+    if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )

     {
     {

-        pwz2[n] = (wchar_t)(unsigned char)psz[n];
+        puts("ERROR: UTF-8 decoding failed.");

     }
     }

+    else
+    {
+        // using wxEncodingConverter
+#if 0
+        wxEncodingConverter ec;
+        ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
+        ec.Convert(wbuf, buf);
+#else // using wxCSConv
+        wxCSConv conv(_T("koi8-r"));
+        if ( conv.WC2MB(buf, wbuf, 0 /* not needed wcslen(wbuf) */) <= 0 )
+        {
+            puts("ERROR: conversion to KOI8-R failed.");
+        }
+        else
+#endif

 
 

-    wxString testString3(pwz2, wxConvUTF8);
-    delete [] pwz2;
-
-    printf("Encoding '%s' -> '%s'\n", psz, testString3.c_str());
+        printf("The resulting string (in koi8-r): %s\n", buf);
+    }

 }
 
 #endif // TEST_WCHAR
 }
 
 #endif // TEST_WCHAR


@@ -1784,16 +2623,21 @@ static void TestUtf8()
 
 #ifdef TEST_ZIP
 
 
 #ifdef TEST_ZIP
 

+#include "wx/filesys.h"
+#include "wx/fs_zip.h"

 #include "wx/zipstrm.h"
 
 #include "wx/zipstrm.h"
 

+static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
+

 static void TestZipStreamRead()
 {
     puts("*** Testing ZIP reading ***\n");
 
 static void TestZipStreamRead()
 {
     puts("*** Testing ZIP reading ***\n");
 

-    wxZipInputStream istr(_T("idx.zip"), _T("IDX.txt"));
+    static const wxChar *filename = _T("foo");
+    wxZipInputStream istr(TESTFILE_ZIP, filename);

     printf("Archive size: %u\n", istr.GetSize());
 
     printf("Archive size: %u\n", istr.GetSize());
 

-    puts("Dumping the file:");
+    printf("Dumping the file '%s':\n", filename);

     while ( !istr.Eof() )
     {
         putchar(istr.GetC());
     while ( !istr.Eof() )
     {
         putchar(istr.GetC());


@@ -1803,6 +2647,59 @@ static void TestZipStreamRead()
     puts("\n----- done ------");
 }
 
     puts("\n----- done ------");
 }
 

+static void DumpZipDirectory(wxFileSystem& fs,
+                             const wxString& dir,
+                             const wxString& indent)
+{
+    wxString prefix = wxString::Format(_T("%s#zip:%s"),
+                                         TESTFILE_ZIP, dir.c_str());
+    wxString wildcard = prefix + _T("/*");
+
+    wxString dirname = fs.FindFirst(wildcard, wxDIR);
+    while ( !dirname.empty() )
+    {
+        if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
+        {
+            wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
+
+            break;
+        }
+
+        wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
+
+        DumpZipDirectory(fs, dirname,
+                         indent + wxString(_T(' '), 4));
+
+        dirname = fs.FindNext();
+    }
+
+    wxString filename = fs.FindFirst(wildcard, wxFILE);
+    while ( !filename.empty() )
+    {
+        if ( !filename.StartsWith(prefix, &filename) )
+        {
+            wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
+
+            break;
+        }
+
+        wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
+
+        filename = fs.FindNext();
+    }
+}
+
+static void TestZipFileSystem()
+{
+    puts("*** Testing ZIP file system ***\n");
+
+    wxFileSystem::AddHandler(new wxZipFSHandler);
+    wxFileSystem fs;
+    wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
+
+    DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
+}
+

 #endif // TEST_ZIP
 
 // ----------------------------------------------------------------------------
 #endif // TEST_ZIP
 
 // ----------------------------------------------------------------------------


@@ -1863,6 +2760,8 @@ static void TestZlibStreamRead()
 
 #ifdef TEST_DATETIME
 
 
 #ifdef TEST_DATETIME
 

+#include <math.h>
+

 #include <wx/date.h>
 
 #include <wx/datetime.h>
 #include <wx/date.h>
 
 #include <wx/datetime.h>


@@ -2650,7 +3549,7 @@ static void TestTimeParse()
     }
 }
 
     }
 }
 

-static void TestInteractive()
+static void TestDateTimeInteractive()

 {
     puts("\n*** interactive wxDateTime tests ***");
 
 {
     puts("\n*** interactive wxDateTime tests ***");
 


@@ -2830,6 +3729,32 @@ static void TestTimeZoneBug()
     puts("");
 }
 
     puts("");
 }
 

+static void TestTimeSpanFormat()
+{
+    puts("\n*** wxTimeSpan tests ***");
+
+    static const char *formats[] =
+    {
+        _T("(default) %H:%M:%S"),
+        _T("%E weeks and %D days"),
+        _T("%l milliseconds"),
+        _T("(with ms) %H:%M:%S:%l"),
+        _T("100%% of minutes is %M"),       // test "%%"
+        _T("%D days and %H hours"),
+    };
+
+    wxTimeSpan ts1(1, 2, 3, 4),
+                ts2(111, 222, 333);
+    for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
+    {
+        printf("ts1 = %s\tts2 = %s\n",
+               ts1.Format(formats[n]).c_str(),
+               ts2.Format(formats[n]).c_str());
+    }
+
+    puts("");
+}
+

 #if 0
 
 // test compatibility with the old wxDate/wxTime classes
 #if 0
 
 // test compatibility with the old wxDate/wxTime classes


@@ -3565,10 +4490,9 @@ int main(int argc, char **argv)
         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
     }
 
         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
     }
 

-#ifdef TEST_USLEEP
-    puts("Sleeping for 3 seconds... z-z-z-z-z...");
-    wxUsleep(3000);
-#endif // TEST_USLEEP
+#ifdef TEST_CHARSET
+    TestCharset();
+#endif // TEST_CHARSET

 
 #ifdef TEST_CMDLINE
     static const wxCmdLineEntryDesc cmdLineDesc[] =
 
 #ifdef TEST_CMDLINE
     static const wxCmdLineEntryDesc cmdLineDesc[] =


@@ -3684,6 +4608,10 @@ int main(int argc, char **argv)
     TestDllLoad();
 #endif // TEST_DLLLOADER
 
     TestDllLoad();
 #endif // TEST_DLLLOADER
 

+#ifdef TEST_ENVIRON
+    TestEnvironment();
+#endif // TEST_ENVIRON
+

 #ifdef TEST_EXECUTE
     TestExecute();
 #endif // TEST_EXECUTE
 #ifdef TEST_EXECUTE
     TestExecute();
 #endif // TEST_EXECUTE


@@ -3696,6 +4624,10 @@ int main(int argc, char **argv)
     TestListCtor();
 #endif // TEST_LIST
 
     TestListCtor();
 #endif // TEST_LIST
 

+#ifdef TEST_LOCALE
+    TestDefaultLang();
+#endif // TEST_LOCALE
+

 #ifdef TEST_LOG
     wxString s;
     for ( size_t n = 0; n < 8000; n++ )
 #ifdef TEST_LOG
     wxString s;
     for ( size_t n = 0; n < 8000; n++ )


@@ -3717,10 +4649,24 @@ int main(int argc, char **argv)
 
 #ifdef TEST_FILE
     if ( 0 )
 
 #ifdef TEST_FILE
     if ( 0 )

+    {

         TestFileRead();
         TestFileRead();

-    TestTextFileRead();
+        TestTextFileRead();
+    }
+    TestFileCopy();

 #endif // TEST_FILE
 
 #endif // TEST_FILE
 

+#ifdef TEST_FILENAME
+    TestFileNameSplit();
+    if ( 0 )
+    {
+        TestFileNameConstruction();
+        TestFileNameCwd();
+        TestFileNameComparison();
+        TestFileNameOperations();
+    }
+#endif // TEST_FILENAME
+

 #ifdef TEST_THREADS
     int nCPUs = wxThread::GetCPUCount();
     printf("This system has %d CPUs\n", nCPUs);
 #ifdef TEST_THREADS
     int nCPUs = wxThread::GetCPUCount();
     printf("This system has %d CPUs\n", nCPUs);


@@ -3766,10 +4712,14 @@ int main(int argc, char **argv)
 
 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));
 
 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));

-    if ( 0 )
+    if ( 1 )
+    {

         TestMimeEnum();
         TestMimeEnum();

-    TestMimeOverride();
-    TestMimeFilename();
+        TestMimeOverride();
+        TestMimeFilename();
+    }
+    else
+        TestMimeAssociate();

 #endif // TEST_MIME
 
 #ifdef TEST_INFO_FUNCTIONS
 #endif // TEST_MIME
 
 #ifdef TEST_INFO_FUNCTIONS


@@ -3777,6 +4727,14 @@ int main(int argc, char **argv)
     TestUserInfo();
 #endif // TEST_INFO_FUNCTIONS
 
     TestUserInfo();
 #endif // TEST_INFO_FUNCTIONS
 

+#ifdef TEST_PATHLIST
+    TestPathList();
+#endif // TEST_PATHLIST
+
+#ifdef TEST_REGCONF
+    TestRegConfWrite();
+#endif // TEST_REGCONF
+

 #ifdef TEST_REGISTRY
     if ( 0 )
         TestRegistryRead();
 #ifdef TEST_REGISTRY
     if ( 0 )
         TestRegistryRead();


@@ -3787,13 +4745,34 @@ int main(int argc, char **argv)
     if ( 0 )
     {
         TestSocketServer();
     if ( 0 )
     {
         TestSocketServer();

-        TestSocketClient();
-        TestProtocolFtp();

     }
     }

-        TestProtocolFtpUpload();
+        TestSocketClient();

 #endif // TEST_SOCKETS
 
 #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
 #ifdef TEST_STREAMS

+    if ( 0 )
+    TestFileStream();

     TestMemoryStream();
 #endif // TEST_STREAMS
 
     TestMemoryStream();
 #endif // TEST_STREAMS
 


@@ -3821,10 +4800,16 @@ int main(int argc, char **argv)
 
         TestTimeZoneBug();
     }
 
         TestTimeZoneBug();
     }

+    TestTimeSpanFormat();

     if ( 0 )
     if ( 0 )

-        TestInteractive();
+        TestDateTimeInteractive();

 #endif // TEST_DATETIME
 
 #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();
 #ifdef TEST_VCARD
     if ( 0 )
     TestVCardRead();


@@ -3836,7 +4821,9 @@ int main(int argc, char **argv)
 #endif // TEST_WCHAR
 
 #ifdef TEST_ZIP
 #endif // TEST_WCHAR
 
 #ifdef TEST_ZIP

-    TestZipStreamRead();
+    if ( 0 )
+        TestZipStreamRead();
+    TestZipFileSystem();

 #endif // TEST_ZIP
 
 #ifdef TEST_ZLIB
 #endif // TEST_ZIP
 
 #ifdef TEST_ZLIB