Initial checkin of the wxFrame support added by Aleks G.

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

diff --git a/samples/console/console.cpp b/samples/console/console.cpp
index 74b31145f19047db95f944eeaa1504e0204ed8ac..59d0bda4c0f2e4dbe41ea50efe9101fd0257ad28 100644 (file)
--- a/samples/console/console.cpp
+++ b/samples/console/console.cpp
@@ -37,25 +37,31 @@
 
 //#define TEST_ARRAYS
 //#define TEST_CMDLINE
 
 //#define TEST_ARRAYS
 //#define TEST_CMDLINE

-#define TEST_DATETIME
+//#define TEST_DATETIME

 //#define TEST_DIR
 //#define TEST_DLLLOADER
 //#define TEST_DIR
 //#define TEST_DLLLOADER

+//#define TEST_ENVIRON

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

+//#define TEST_FILENAME
+#define TEST_FTP

 //#define TEST_HASH
 //#define TEST_LIST
 //#define TEST_LOG
 //#define TEST_LONGLONG
 //#define TEST_MIME
 //#define TEST_INFO_FUNCTIONS
 //#define TEST_HASH
 //#define TEST_LIST
 //#define TEST_LOG
 //#define TEST_LONGLONG
 //#define TEST_MIME
 //#define TEST_INFO_FUNCTIONS

+//#define TEST_REGISTRY

 //#define TEST_SOCKETS
 //#define TEST_SOCKETS

+//#define TEST_STREAMS

 //#define TEST_STRINGS
 //#define TEST_THREADS
 //#define TEST_TIMER
 //#define TEST_STRINGS
 //#define TEST_THREADS
 //#define TEST_TIMER

-//#define TEST_VCARD
+//#define TEST_VCARD            -- don't enable this (VZ)

 //#define TEST_WCHAR
 //#define TEST_ZIP
 //#define TEST_WCHAR
 //#define TEST_ZIP

+//#define TEST_ZLIB

 
 // ----------------------------------------------------------------------------
 // test class for container objects
 
 // ----------------------------------------------------------------------------
 // test class for container objects


@@ -280,6 +286,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
 // ----------------------------------------------------------------------------


@@ -293,9 +336,9 @@ static void TestExecute()
     puts("*** testing wxExecute ***");
 
 #ifdef __UNIX__
     puts("*** testing wxExecute ***");
 
 #ifdef __UNIX__

-    #define COMMAND "echo hi"
+    #define COMMAND "cat -n ../../Makefile" // "echo hi"

     #define SHELL_COMMAND "echo hi from shell"
     #define SHELL_COMMAND "echo hi from shell"

-    #define REDIRECT_COMMAND "date"
+    #define REDIRECT_COMMAND COMMAND // "date"

 #elif defined(__WXMSW__)
     #define COMMAND "command.com -c 'echo hi'"
     #define SHELL_COMMAND "echo hi"
 #elif defined(__WXMSW__)
     #define COMMAND "command.com -c 'echo hi'"
     #define SHELL_COMMAND "echo hi"


@@ -354,6 +397,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()


@@ -367,7 +411,7 @@ static void TestFileRead()
 
         puts("File dump:\n----------");
 
 
         puts("File dump:\n----------");
 

-        static const size_t len = 1024;
+        static const off_t len = 1024;

         char buf[len];
         for ( ;; )
         {
         char buf[len];
         for ( ;; )
         {


@@ -403,6 +447,24 @@ static void TestTextFileRead()
     {
         printf("Number of lines: %u\n", file.GetLineCount());
         printf("Last line: '%s'\n", file.GetLastLine().c_str());
     {
         printf("Number of lines: %u\n", file.GetLineCount());
         printf("Last line: '%s'\n", file.GetLastLine().c_str());

+
+        wxString s;
+
+        puts("\nDumping the entire file:");
+        for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
+        {
+            printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
+        }
+        printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
+
+        puts("\nAnd now backwards:");
+        for ( s = file.GetLastLine();
+              file.GetCurrentLine() != 0;
+              s = file.GetPrevLine() )
+        {
+            printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
+        }
+        printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());

     }
     else
     {
     }
     else
     {


@@ -412,6 +474,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
 
 // ----------------------------------------------------------------------------


@@ -477,6 +588,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
 // ----------------------------------------------------------------------------


@@ -613,6 +813,8 @@ static wxMimeTypesManager g_mimeManager;
 
 static void TestMimeEnum()
 {
 
 static void TestMimeEnum()
 {

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

     wxArrayString mimetypes;
 
     size_t count = g_mimeManager.EnumAllFileTypes(mimetypes);
     wxArrayString mimetypes;
 
     size_t count = g_mimeManager.EnumAllFileTypes(mimetypes);


@@ -704,6 +906,32 @@ static void TestMimeFilename()
     }
 }
 
     }
 }
 

+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 = g_mimeManager.Associate(ftInfo);
+    if ( !ft )
+    {
+        wxPuts(_T("ERROR: failed to create association!"));
+    }
+    else
+    {
+        // TODO: read it back
+        delete ft;
+    }
+}
+

 #endif // TEST_MIME
 
 // ----------------------------------------------------------------------------
 #endif // TEST_MIME
 
 // ----------------------------------------------------------------------------


@@ -1034,6 +1262,120 @@ static void TestLongLongComparison()
 
 #endif // TEST_LONGLONG
 
 
 #endif // TEST_LONGLONG
 

+// ----------------------------------------------------------------------------
+// registry
+// ----------------------------------------------------------------------------
+
+// this is for MSW only
+#ifndef __WXMSW__
+    #undef TEST_REGISTRY
+#endif
+
+#ifdef TEST_REGISTRY
+
+#include <wx/msw/registry.h>
+
+// I chose this one because I liked its name, but it probably only exists under
+// NT
+static const wxChar *TESTKEY =
+    _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
+
+static void TestRegistryRead()
+{
+    puts("*** testing registry reading ***");
+
+    wxRegKey key(TESTKEY);
+    printf("The test key name is '%s'.\n", key.GetName().c_str());
+    if ( !key.Open() )
+    {
+        puts("ERROR: test key can't be opened, aborting test.");
+
+        return;
+    }
+
+    size_t nSubKeys, nValues;
+    if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
+    {
+        printf("It has %u subkeys and %u values.\n", nSubKeys, nValues);
+    }
+
+    printf("Enumerating values:\n");
+
+    long dummy;
+    wxString value;
+    bool cont = key.GetFirstValue(value, dummy);
+    while ( cont )
+    {
+        printf("Value '%s': type ", value.c_str());
+        switch ( key.GetValueType(value) )
+        {
+            case wxRegKey::Type_None:   printf("ERROR (none)"); break;
+            case wxRegKey::Type_String: printf("SZ"); break;
+            case wxRegKey::Type_Expand_String: printf("EXPAND_SZ"); break;
+            case wxRegKey::Type_Binary: printf("BINARY"); break;
+            case wxRegKey::Type_Dword: printf("DWORD"); break;
+            case wxRegKey::Type_Multi_String: printf("MULTI_SZ"); break;
+            default: printf("other (unknown)"); break;
+        }
+
+        printf(", value = ");
+        if ( key.IsNumericValue(value) )
+        {
+            long val;
+            key.QueryValue(value, &val);
+            printf("%ld", val);
+        }
+        else // string
+        {
+            wxString val;
+            key.QueryValue(value, val);
+            printf("'%s'", val.c_str());
+
+            key.QueryRawValue(value, val);
+            printf(" (raw value '%s')", val.c_str());
+        }
+
+        putchar('\n');
+
+        cont = key.GetNextValue(value, dummy);
+    }
+}
+
+static void TestRegistryAssociation()
+{
+    /*
+       The second call to deleteself genertaes an error message, with a
+       messagebox saying .flo is crucial to system operation, while the .ddf
+       call also fails, but with no error message
+    */
+
+    wxRegKey key;
+
+    key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
+    key.Create();
+    key = "ddxf_auto_file" ;
+    key.SetName("HKEY_CLASSES_ROOT\\.flo" );
+    key.Create();
+    key = "ddxf_auto_file" ;
+    key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
+    key.Create();
+    key = "program,0" ;
+    key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
+    key.Create();
+    key = "program \"%1\"" ;
+
+    key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
+    key.DeleteSelf();
+    key.SetName("HKEY_CLASSES_ROOT\\.flo" );
+    key.DeleteSelf();
+    key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
+    key.DeleteSelf();
+    key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
+    key.DeleteSelf();
+}
+
+#endif // TEST_REGISTRY
+

 // ----------------------------------------------------------------------------
 // sockets
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // sockets
 // ----------------------------------------------------------------------------


@@ -1042,7 +1384,6 @@ static void TestLongLongComparison()
 
 #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()


@@ -1165,56 +1506,84 @@ static void TestSocketClient()
     }
 }
 
     }
 }
 

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

 
 

-    wxLog::AddTraceMask(_T("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
         {


@@ -1228,7 +1597,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;


@@ -1237,50 +1606,258 @@ static void TestProtocolFtp()
     }
 }
 
     }
 }
 

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

 {
 {

-    puts("*** Testing wxFTP uploading ***\n");
+    puts("*** Testing wxFTP file listing ***\n");

 
 

-    wxLog::AddTraceMask(_T("ftp"));
+    // test CWD
+    if ( !ftp.ChDir(directory) )
+    {
+        printf("ERROR: failed to cd to %s\n", directory);
+    }

 
 

-    static const char *hostname = "localhost";
+    printf("Current directory is '%s'\n", ftp.Pwd().c_str());

 
 

-    printf("--- Attempting to connect to %s:21...\n", hostname);
+    // 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");
+    }

 
 

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

     {
     {

-        printf("ERROR: failed to connect to %s\n", hostname);
+        puts("ERROR: failed to get LIST of files");

     }
     else
     {
     }
     else
     {

-        printf("--- Connected to %s, current directory is '%s'\n",
-               hostname, ftp.Pwd().c_str());
+        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");
+    }
+
+    if ( !ftp.ChDir(_T("..")) )
+    {
+        puts("ERROR: failed to cd to ..");
+    }
+
+    printf("Current directory is '%s'\n", ftp.Pwd().c_str());
+}
+
+static void TestFtpDownload()
+{
+    puts("*** Testing wxFTP download ***\n");

 
 

-        // upload a file
-        static const char *file1 = "test1";
-        static const char *file2 = "test2";
-        wxOutputStream *out = ftp.GetOutputStream(file1);
-        if ( out )
+    // test RETR
+    wxInputStream *in = ftp.GetInputStream(filename);
+    if ( !in )
+    {
+        printf("ERROR: couldn't get input stream for %s\n", filename);
+    }
+    else
+    {
+        size_t size = in->StreamSize();
+        printf("Reading file %s (%u bytes)...", filename, size);
+        fflush(stdout);
+
+        char *data = new char[size];
+        if ( !in->Read(data, size) )

         {
         {

-            printf("--- Uploading to %s ---\n", file1);
-            out->Write("First hello", 11);
-            delete out;
+            puts("ERROR: read error");

         }
         }

+        else
+        {
+            printf("\nContents of %s:\n%s\n", filename, data);
+        }
+
+        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;

 
 

-        out = ftp.GetOutputStream(file2);
-        if ( out )
+        // special handling of LIST and NLST as they require data connection
+        wxString start(buf, 4);
+        start.MakeUpper();
+        if ( start == "LIST" || start == "NLST" )

         {
         {

-            printf("--- Uploading to %s ---\n", file1);
-            out->Write("Second hello", 12);
-            delete out;
+            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
+        {
+            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
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_STREAMS
+
+#include <wx/mstream.h>
+
+static void TestMemoryStream()
+{
+    puts("*** Testing wxMemoryInputStream ***");
+
+    wxChar buf[1024];
+    wxStrncpy(buf, _T("Hello, stream!"), WXSIZEOF(buf));
+
+    wxMemoryInputStream memInpStream(buf, wxStrlen(buf));
+    printf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
+    while ( !memInpStream.Eof() )
+    {
+        putchar(memInpStream.GetC());
+    }
+
+    puts("\n*** wxMemoryInputStream test done ***");
+}
+
+#endif // TEST_STREAMS

 
 // ----------------------------------------------------------------------------
 // timers
 
 // ----------------------------------------------------------------------------
 // timers


@@ -1643,6 +2220,58 @@ static void TestZipStreamRead()
 
 #endif // TEST_ZIP
 
 
 #endif // TEST_ZIP
 

+// ----------------------------------------------------------------------------
+// ZLIB stream
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_ZLIB
+
+#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";
+
+static void TestZlibStreamWrite()
+{
+    puts("*** Testing Zlib stream reading ***\n");
+
+    wxFileOutputStream fileOutStream(FILENAME_GZ);
+    wxZlibOutputStream ostr(fileOutStream, 0);
+    printf("Compressing the test string... ");
+    ostr.Write(TEST_DATA, sizeof(TEST_DATA));
+    if ( !ostr )
+    {
+        puts("(ERROR: failed)");
+    }
+    else
+    {
+        puts("(ok)");
+    }
+
+    puts("\n----- done ------");
+}
+
+static void TestZlibStreamRead()
+{
+    puts("*** Testing Zlib stream reading ***\n");
+
+    wxFileInputStream fileInStream(FILENAME_GZ);
+    wxZlibInputStream istr(fileInStream);
+    printf("Archive size: %u\n", istr.GetSize());
+
+    puts("Dumping the file:");
+    while ( !istr.Eof() )
+    {
+        putchar(istr.GetC());
+        fflush(stdout);
+    }
+
+    puts("\n----- done ------");
+}
+
+#endif // TEST_ZLIB
+

 // ----------------------------------------------------------------------------
 // date time
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // date time
 // ----------------------------------------------------------------------------


@@ -2436,7 +3065,7 @@ static void TestTimeParse()
     }
 }
 
     }
 }
 

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

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


@@ -2484,7 +3113,25 @@ static void TestTimeMS()
 
     printf("Now = %s\n", dt1.Format("%H:%M:%S:%l").c_str());
     printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());
 
     printf("Now = %s\n", dt1.Format("%H:%M:%S:%l").c_str());
     printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());

-    printf("Difference is %s\n", (dt2 - dt1).Format("%l").c_str());
+    printf("Dummy loop: ");
+    for ( int i = 0; i < 6000; i++ )
+    {
+        //for ( int j = 0; j < 10; j++ )
+        {
+            wxString s;
+            s.Printf("%g", sqrt(i));
+        }
+
+        if ( !(i % 100) )
+            putchar('.');
+    }
+    puts(", done");
+
+    dt1 = dt2;
+    dt2 = wxDateTime::UNow();
+    printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());
+
+    printf("Loop executed in %s ms\n", (dt2 - dt1).Format("%l").c_str());

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


@@ -2885,11 +3532,57 @@ static void PrintArray(const char* name, const wxArrayString& array)
     }
 }
 
     }
 }
 

-static int StringLenCompare(const wxString& first, const wxString& second)
+static void PrintArray(const char* name, const wxArrayInt& 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]);
+    }
+}
+
+int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
+                                    const wxString& second)

 {
     return first.length() - second.length();
 }
 
 {
     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);
+}
+

 #include "wx/dynarray.h"
 
 WX_DECLARE_OBJARRAY(Bar, ArrayBars);
 #include "wx/dynarray.h"
 
 WX_DECLARE_OBJARRAY(Bar, ArrayBars);


@@ -3349,6 +4042,8 @@ int main(int argc, char **argv)
 #endif // TEST_STRINGS
 
 #ifdef TEST_ARRAYS
 #endif // TEST_STRINGS
 
 #ifdef TEST_ARRAYS

+    if ( 0 )
+    {

     wxArrayString a1;
     a1.Add("tiger");
     a1.Add("cat");
     wxArrayString a1;
     a1.Add("tiger");
     a1.Add("cat");


@@ -3392,6 +4087,8 @@ int main(int argc, char **argv)
     PrintArray("a1", a1);
 
     TestArrayOfObjects();
     PrintArray("a1", a1);
 
     TestArrayOfObjects();

+    }
+    TestArrayOfInts();

 #endif // TEST_ARRAYS
 
 #ifdef TEST_DIR
 #endif // TEST_ARRAYS
 
 #ifdef TEST_DIR


@@ -3402,6 +4099,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


@@ -3434,10 +4135,25 @@ int main(int argc, char **argv)
 #endif // TEST_LOG
 
 #ifdef TEST_FILE
 #endif // TEST_LOG
 
 #ifdef TEST_FILE

-    TestFileRead();
-    TestTextFileRead();
+    if ( 0 )
+    {
+        TestFileRead();
+        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);


@@ -3483,10 +4199,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


@@ -3494,22 +4214,51 @@ int main(int argc, char **argv)
     TestUserInfo();
 #endif // TEST_INFO_FUNCTIONS
 
     TestUserInfo();
 #endif // TEST_INFO_FUNCTIONS
 

+#ifdef TEST_REGISTRY
+    if ( 0 )
+        TestRegistryRead();
+    TestRegistryAssociation();
+#endif // TEST_REGISTRY
+

 #ifdef TEST_SOCKETS
     if ( 0 )
     {
         TestSocketServer();
 #ifdef TEST_SOCKETS
     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
+    TestMemoryStream();
+#endif // TEST_STREAMS
+

 #ifdef TEST_TIMER
     TestStopWatch();
 #endif // TEST_TIMER
 
 #ifdef TEST_DATETIME
 #ifdef TEST_TIMER
     TestStopWatch();
 #endif // TEST_TIMER
 
 #ifdef TEST_DATETIME

-    if ( 0 )
+    if ( 1 )

     {
         TestTimeSet();
         TestTimeStatic();
     {
         TestTimeSet();
         TestTimeStatic();


@@ -3524,12 +4273,12 @@ int main(int argc, char **argv)
         TestTimeArithmetics();
         TestTimeHolidays();
         TestTimeFormat();
         TestTimeArithmetics();
         TestTimeHolidays();
         TestTimeFormat();

+        TestTimeMS();

 
         TestTimeZoneBug();
     }
 
         TestTimeZoneBug();
     }

-    TestTimeMS();

     if ( 0 )
     if ( 0 )

-        TestInteractive();
+        TestDateTimeInteractive();

 #endif // TEST_DATETIME
 
 #ifdef TEST_VCARD
 #endif // TEST_DATETIME
 
 #ifdef TEST_VCARD


@@ -3546,6 +4295,12 @@ int main(int argc, char **argv)
     TestZipStreamRead();
 #endif // TEST_ZIP
 
     TestZipStreamRead();
 #endif // TEST_ZIP
 

+#ifdef TEST_ZLIB
+    if ( 0 )
+    TestZlibStreamWrite();
+    TestZlibStreamRead();
+#endif // TEST_ZLIB
+

     wxUninitialize();
 
     return 0;
     wxUninitialize();
 
     return 0;