samples/console/console.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/console/console.cpp
   3 // Purpose:     A sample console (as opposed to GUI) program using wxWidgets
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04.10.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // IMPORTANT NOTE FOR WXWIDGETS USERS:
  13 // If you're a wxWidgets user and you're looking at this file to learn how to
  14 // structure a wxWidgets console application, then you don't have much to learn.
  15 // This application is used more for testing rather than as sample but
  16 // basically the following simple block is enough for you to start your
  17 // own console application:
  18
  19 /*
  20     int main(int argc, char **argv)
  21     {
  22         wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
  23
  24         wxInitializer initializer;
  25         if ( !initializer )
  26         {
  27             fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
  28             return -1;
  29         }
  30
  31         static const wxCmdLineEntryDesc cmdLineDesc[] =
  32         {
  33             { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
  34                 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
  35             // ... your other command line options here...
  36
  37             { wxCMD_LINE_NONE }
  38         };
  39
  40         wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
  41         switch ( parser.Parse() )
  42         {
  43             case -1:
  44                 wxLogMessage(_T("Help was given, terminating."));
  45                 break;
  46
  47             case 0:
  48                 // everything is ok; proceed
  49                 break;
  50
  51             default:
  52                 wxLogMessage(_T("Syntax error detected, aborting."));
  53                 break;
  54         }
  55
  56         // do something useful here
  57
  58         return 0;
  59     }
  60 */
  61
  62
  63 // ============================================================================
  64 // declarations
  65 // ============================================================================
  66
  67 // ----------------------------------------------------------------------------
  68 // headers
  69 // ----------------------------------------------------------------------------
  70
  71 #include "wx/defs.h"
  72
  73 #include <stdio.h>
  74
  75 #include "wx/string.h"
  76 #include "wx/file.h"
  77 #include "wx/filename.h"
  78 #include "wx/app.h"
  79 #include "wx/log.h"
  80 #include "wx/apptrait.h"
  81 #include "wx/platinfo.h"
  82 #include "wx/wxchar.h"
  83
  84 // without this pragma, the stupid compiler precompiles #defines below so that
  85 // changing them doesn't "take place" later!
  86 #ifdef __VISUALC__
  87     #pragma hdrstop
  88 #endif
  89
  90 // ----------------------------------------------------------------------------
  91 // conditional compilation
  92 // ----------------------------------------------------------------------------
  93
  94 /*
  95    A note about all these conditional compilation macros: this file is used
  96    both as a test suite for various non-GUI wxWidgets classes and as a
  97    scratchpad for quick tests. So there are two compilation modes: if you
  98    define TEST_ALL all tests are run, otherwise you may enable the individual
  99    tests individually in the "#else" branch below.
 100  */
 101
 102 // what to test (in alphabetic order)? Define TEST_ALL to 0 to do a single
 103 // test, define it to 1 to do all tests.
 104 #define TEST_ALL 1
 105
 106
 107 #if TEST_ALL
 108     #define TEST_CMDLINE
 109     #define TEST_DATETIME
 110     #define TEST_DIR
 111     #define TEST_DYNLIB
 112     #define TEST_ENVIRON
 113     #define TEST_FILE
 114     #define TEST_FILECONF
 115     #define TEST_FILENAME
 116     #define TEST_FILETIME
 117     #define TEST_FTP
 118     #define TEST_INFO_FUNCTIONS
 119     #define TEST_LOCALE
 120     #define TEST_LOG
 121     #define TEST_MIME
 122     #define TEST_MODULE
 123     #define TEST_PATHLIST
 124     #define TEST_PRINTF
 125     #define TEST_REGCONF
 126     #define TEST_REGEX
 127     #define TEST_REGISTRY
 128     #define TEST_SCOPEGUARD
 129     #define TEST_SNGLINST
 130 //    #define TEST_SOCKETS  --FIXME! (RN)
 131     #define TEST_STACKWALKER
 132     #define TEST_STDPATHS
 133     #define TEST_STREAMS
 134     #define TEST_TEXTSTREAM
 135     #define TEST_THREADS
 136     #define TEST_TIMER
 137 //    #define TEST_VOLUME   --FIXME! (RN)
 138     #define TEST_WCHAR
 139     #define TEST_ZIP
 140 #else // #if TEST_ALL
 141     #define TEST_FTP
 142 #endif
 143
 144 // some tests are interactive, define this to run them
 145 #ifdef TEST_INTERACTIVE
 146     #undef TEST_INTERACTIVE
 147
 148     #define TEST_INTERACTIVE 1
 149 #else
 150     #define TEST_INTERACTIVE 0
 151 #endif
 152
 153 // ============================================================================
 154 // implementation
 155 // ============================================================================
 156
 157 // ----------------------------------------------------------------------------
 158 // helper functions
 159 // ----------------------------------------------------------------------------
 160
 161 #if defined(TEST_SOCKETS)
 162
 163 // replace TABs with \t and CRs with \n
 164 static wxString MakePrintable(const wxChar *s)
 165 {
 166     wxString str(s);
 167     (void)str.Replace(_T("\t"), _T("\\t"));
 168     (void)str.Replace(_T("\n"), _T("\\n"));
 169     (void)str.Replace(_T("\r"), _T("\\r"));
 170
 171     return str;
 172 }
 173
 174 #endif // MakePrintable() is used
 175
 176 // ----------------------------------------------------------------------------
 177 // wxCmdLineParser
 178 // ----------------------------------------------------------------------------
 179
 180 #ifdef TEST_CMDLINE
 181
 182 #include "wx/cmdline.h"
 183 #include "wx/datetime.h"
 184
 185 #if wxUSE_CMDLINE_PARSER
 186
 187 static void ShowCmdLine(const wxCmdLineParser& parser)
 188 {
 189     wxString s = _T("Command line parsed successfully:\nInput files: ");
 190
 191     size_t count = parser.GetParamCount();
 192     for ( size_t param = 0; param < count; param++ )
 193     {
 194         s << parser.GetParam(param) << ' ';
 195     }
 196
 197     s << '\n'
 198       << _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
 199       << _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
 200
 201     wxString strVal;
 202     long lVal;
 203     double dVal;
 204     wxDateTime dt;
 205     if ( parser.Found(_T("o"), &strVal) )
 206         s << _T("Output file:\t") << strVal << '\n';
 207     if ( parser.Found(_T("i"), &strVal) )
 208         s << _T("Input dir:\t") << strVal << '\n';
 209     if ( parser.Found(_T("s"), &lVal) )
 210         s << _T("Size:\t") << lVal << '\n';
 211     if ( parser.Found(_T("f"), &dVal) )
 212         s << _T("Double:\t") << dVal << '\n';
 213     if ( parser.Found(_T("d"), &dt) )
 214         s << _T("Date:\t") << dt.FormatISODate() << '\n';
 215     if ( parser.Found(_T("project_name"), &strVal) )
 216         s << _T("Project:\t") << strVal << '\n';
 217
 218     wxLogMessage(s);
 219 }
 220
 221 #endif // wxUSE_CMDLINE_PARSER
 222
 223 static void TestCmdLineConvert()
 224 {
 225     static const wxChar *cmdlines[] =
 226     {
 227         _T("arg1 arg2"),
 228         _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
 229         _T("literal \\\" and \"\""),
 230     };
 231
 232     for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
 233     {
 234         const wxChar *cmdline = cmdlines[n];
 235         wxPrintf(_T("Parsing: %s\n"), cmdline);
 236         wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
 237
 238         size_t count = args.GetCount();
 239         wxPrintf(_T("\targc = %u\n"), count);
 240         for ( size_t arg = 0; arg < count; arg++ )
 241         {
 242             wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
 243         }
 244     }
 245 }
 246
 247 #endif // TEST_CMDLINE
 248
 249 // ----------------------------------------------------------------------------
 250 // wxDir
 251 // ----------------------------------------------------------------------------
 252
 253 #ifdef TEST_DIR
 254
 255 #include "wx/dir.h"
 256
 257 #ifdef __UNIX__
 258     static const wxChar *ROOTDIR = _T("/");
 259     static const wxChar *TESTDIR = _T("/usr/local/share");
 260 #elif defined(__WXMSW__) || defined(__DOS__) || defined(__OS2__)
 261     static const wxChar *ROOTDIR = _T("c:\\");
 262     static const wxChar *TESTDIR = _T("d:\\");
 263 #else
 264     #error "don't know where the root directory is"
 265 #endif
 266
 267 static void TestDirEnumHelper(wxDir& dir,
 268                               int flags = wxDIR_DEFAULT,
 269                               const wxString& filespec = wxEmptyString)
 270 {
 271     wxString filename;
 272
 273     if ( !dir.IsOpened() )
 274         return;
 275
 276     bool cont = dir.GetFirst(&filename, filespec, flags);
 277     while ( cont )
 278     {
 279         wxPrintf(_T("\t%s\n"), filename.c_str());
 280
 281         cont = dir.GetNext(&filename);
 282     }
 283
 284     wxPuts(wxEmptyString);
 285 }
 286
 287 #if TEST_ALL
 288
 289 static void TestDirEnum()
 290 {
 291     wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
 292
 293     wxString cwd = wxGetCwd();
 294     if ( !wxDir::Exists(cwd) )
 295     {
 296         wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
 297         return;
 298     }
 299
 300     wxDir dir(cwd);
 301     if ( !dir.IsOpened() )
 302     {
 303         wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
 304         return;
 305     }
 306
 307     wxPuts(_T("Enumerating everything in current directory:"));
 308     TestDirEnumHelper(dir);
 309
 310     wxPuts(_T("Enumerating really everything in current directory:"));
 311     TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
 312
 313     wxPuts(_T("Enumerating object files in current directory:"));
 314     TestDirEnumHelper(dir, wxDIR_DEFAULT, _T("*.o*"));
 315
 316     wxPuts(_T("Enumerating directories in current directory:"));
 317     TestDirEnumHelper(dir, wxDIR_DIRS);
 318
 319     wxPuts(_T("Enumerating files in current directory:"));
 320     TestDirEnumHelper(dir, wxDIR_FILES);
 321
 322     wxPuts(_T("Enumerating files including hidden in current directory:"));
 323     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 324
 325     dir.Open(ROOTDIR);
 326
 327     wxPuts(_T("Enumerating everything in root directory:"));
 328     TestDirEnumHelper(dir, wxDIR_DEFAULT);
 329
 330     wxPuts(_T("Enumerating directories in root directory:"));
 331     TestDirEnumHelper(dir, wxDIR_DIRS);
 332
 333     wxPuts(_T("Enumerating files in root directory:"));
 334     TestDirEnumHelper(dir, wxDIR_FILES);
 335
 336     wxPuts(_T("Enumerating files including hidden in root directory:"));
 337     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 338
 339     wxPuts(_T("Enumerating files in non existing directory:"));
 340     wxDir dirNo(_T("nosuchdir"));
 341     TestDirEnumHelper(dirNo);
 342 }
 343
 344 #endif // TEST_ALL
 345
 346 class DirPrintTraverser : public wxDirTraverser
 347 {
 348 public:
 349     virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
 350     {
 351         return wxDIR_CONTINUE;
 352     }
 353
 354     virtual wxDirTraverseResult OnDir(const wxString& dirname)
 355     {
 356         wxString path, name, ext;
 357         wxFileName::SplitPath(dirname, &path, &name, &ext);
 358
 359         if ( !ext.empty() )
 360             name << _T('.') << ext;
 361
 362         wxString indent;
 363         for ( const wxChar *p = path.c_str(); *p; p++ )
 364         {
 365             if ( wxIsPathSeparator(*p) )
 366                 indent += _T("    ");
 367         }
 368
 369         wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
 370
 371         return wxDIR_CONTINUE;
 372     }
 373 };
 374
 375 static void TestDirTraverse()
 376 {
 377     wxPuts(_T("*** Testing wxDir::Traverse() ***"));
 378
 379     // enum all files
 380     wxArrayString files;
 381     size_t n = wxDir::GetAllFiles(TESTDIR, &files);
 382     wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
 383     if ( n > 1 )
 384     {
 385         wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
 386         wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
 387     }
 388
 389     // enum again with custom traverser
 390     wxPuts(_T("Now enumerating directories:"));
 391     wxDir dir(TESTDIR);
 392     DirPrintTraverser traverser;
 393     dir.Traverse(traverser, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN);
 394 }
 395
 396 #if TEST_ALL
 397
 398 static void TestDirExists()
 399 {
 400     wxPuts(_T("*** Testing wxDir::Exists() ***"));
 401
 402     static const wxChar *dirnames[] =
 403     {
 404         _T("."),
 405 #if defined(__WXMSW__)
 406         _T("c:"),
 407         _T("c:\\"),
 408         _T("\\\\share\\file"),
 409         _T("c:\\dos"),
 410         _T("c:\\dos\\"),
 411         _T("c:\\dos\\\\"),
 412         _T("c:\\autoexec.bat"),
 413 #elif defined(__UNIX__)
 414         _T("/"),
 415         _T("//"),
 416         _T("/usr/bin"),
 417         _T("/usr//bin"),
 418         _T("/usr///bin"),
 419 #endif
 420     };
 421
 422     for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
 423     {
 424         wxPrintf(_T("%-40s: %s\n"),
 425                  dirnames[n],
 426                  wxDir::Exists(dirnames[n]) ? _T("exists")
 427                                             : _T("doesn't exist"));
 428     }
 429 }
 430
 431 #endif // TEST_ALL
 432
 433 #endif // TEST_DIR
 434
 435 // ----------------------------------------------------------------------------
 436 // wxDllLoader
 437 // ----------------------------------------------------------------------------
 438
 439 #ifdef TEST_DYNLIB
 440
 441 #include "wx/dynlib.h"
 442
 443 static void TestDllLoad()
 444 {
 445 #if defined(__WXMSW__)
 446     static const wxChar *LIB_NAME = _T("kernel32.dll");
 447     static const wxChar *FUNC_NAME = _T("lstrlenA");
 448 #elif defined(__UNIX__)
 449     // weird: using just libc.so does *not* work!
 450     static const wxChar *LIB_NAME = _T("/lib/libc.so.6");
 451     static const wxChar *FUNC_NAME = _T("strlen");
 452 #else
 453     #error "don't know how to test wxDllLoader on this platform"
 454 #endif
 455
 456     wxPuts(_T("*** testing basic wxDynamicLibrary functions ***\n"));
 457
 458     wxDynamicLibrary lib(LIB_NAME);
 459     if ( !lib.IsLoaded() )
 460     {
 461         wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
 462     }
 463     else
 464     {
 465         typedef int (wxSTDCALL *wxStrlenType)(const char *);
 466         wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
 467         if ( !pfnStrlen )
 468         {
 469             wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
 470                      FUNC_NAME, LIB_NAME);
 471         }
 472         else
 473         {
 474             wxPrintf(_T("Calling %s dynamically loaded from %s "),
 475                      FUNC_NAME, LIB_NAME);
 476
 477             if ( pfnStrlen("foo") != 3 )
 478             {
 479                 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
 480             }
 481             else
 482             {
 483                 wxPuts(_T("... ok"));
 484             }
 485         }
 486
 487 #ifdef __WXMSW__
 488         static const wxChar *FUNC_NAME_AW = _T("lstrlen");
 489
 490         typedef int (wxSTDCALL *wxStrlenTypeAorW)(const wxChar *);
 491         wxStrlenTypeAorW
 492             pfnStrlenAorW = (wxStrlenTypeAorW)lib.GetSymbolAorW(FUNC_NAME_AW);
 493         if ( !pfnStrlenAorW )
 494         {
 495             wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
 496                      FUNC_NAME_AW, LIB_NAME);
 497         }
 498         else
 499         {
 500             if ( pfnStrlenAorW(_T("foobar")) != 6 )
 501             {
 502                 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
 503             }
 504         }
 505 #endif // __WXMSW__
 506     }
 507 }
 508
 509 #if defined(__WXMSW__) || defined(__UNIX__)
 510
 511 static void TestDllListLoaded()
 512 {
 513     wxPuts(_T("*** testing wxDynamicLibrary::ListLoaded() ***\n"));
 514
 515     puts("\nLoaded modules:");
 516     wxDynamicLibraryDetailsArray dlls = wxDynamicLibrary::ListLoaded();
 517     const size_t count = dlls.GetCount();
 518     for ( size_t n = 0; n < count; ++n )
 519     {
 520         const wxDynamicLibraryDetails& details = dlls[n];
 521         printf("%-45s", (const char *)details.GetPath().mb_str());
 522
 523         void *addr;
 524         size_t len;
 525         if ( details.GetAddress(&addr, &len) )
 526         {
 527             printf(" %08lx:%08lx",
 528                    (unsigned long)addr, (unsigned long)((char *)addr + len));
 529         }
 530
 531         printf(" %s\n", (const char *)details.GetVersion().mb_str());
 532     }
 533 }
 534
 535 #endif
 536
 537 #endif // TEST_DYNLIB
 538
 539 // ----------------------------------------------------------------------------
 540 // wxGet/SetEnv
 541 // ----------------------------------------------------------------------------
 542
 543 #ifdef TEST_ENVIRON
 544
 545 #include "wx/utils.h"
 546
 547 static wxString MyGetEnv(const wxString& var)
 548 {
 549     wxString val;
 550     if ( !wxGetEnv(var, &val) )
 551         val = _T("<empty>");
 552     else
 553         val = wxString(_T('\'')) + val + _T('\'');
 554
 555     return val;
 556 }
 557
 558 static void TestEnvironment()
 559 {
 560     const wxChar *var = _T("wxTestVar");
 561
 562     wxPuts(_T("*** testing environment access functions ***"));
 563
 564     wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
 565     wxSetEnv(var, _T("value for wxTestVar"));
 566     wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 567     wxSetEnv(var, _T("another value"));
 568     wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 569     wxUnsetEnv(var);
 570     wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 571     wxPrintf(_T("PATH = %s\n"),  MyGetEnv(_T("PATH")).c_str());
 572 }
 573
 574 #endif // TEST_ENVIRON
 575
 576 // ----------------------------------------------------------------------------
 577 // file
 578 // ----------------------------------------------------------------------------
 579
 580 #ifdef TEST_FILE
 581
 582 #include "wx/file.h"
 583 #include "wx/ffile.h"
 584 #include "wx/textfile.h"
 585
 586 static void TestFileRead()
 587 {
 588     wxPuts(_T("*** wxFile read test ***"));
 589
 590     wxFile file(_T("testdata.fc"));
 591     if ( file.IsOpened() )
 592     {
 593         wxPrintf(_T("File length: %lu\n"), file.Length());
 594
 595         wxPuts(_T("File dump:\n----------"));
 596
 597         static const size_t len = 1024;
 598         wxChar buf[len];
 599         for ( ;; )
 600         {
 601             size_t nRead = file.Read(buf, len);
 602             if ( nRead == (size_t)wxInvalidOffset )
 603             {
 604                 wxPrintf(_T("Failed to read the file."));
 605                 break;
 606             }
 607
 608             fwrite(buf, nRead, 1, stdout);
 609
 610             if ( nRead < len )
 611                 break;
 612         }
 613
 614         wxPuts(_T("----------"));
 615     }
 616     else
 617     {
 618         wxPrintf(_T("ERROR: can't open test file.\n"));
 619     }
 620
 621     wxPuts(wxEmptyString);
 622 }
 623
 624 static void TestTextFileRead()
 625 {
 626     wxPuts(_T("*** wxTextFile read test ***"));
 627
 628     wxTextFile file(_T("testdata.fc"));
 629     if ( file.Open() )
 630     {
 631         wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
 632         wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
 633
 634         wxString s;
 635
 636         wxPuts(_T("\nDumping the entire file:"));
 637         for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
 638         {
 639             wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 640         }
 641         wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 642
 643         wxPuts(_T("\nAnd now backwards:"));
 644         for ( s = file.GetLastLine();
 645               file.GetCurrentLine() != 0;
 646               s = file.GetPrevLine() )
 647         {
 648             wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 649         }
 650         wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 651     }
 652     else
 653     {
 654         wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
 655     }
 656
 657     wxPuts(wxEmptyString);
 658 }
 659
 660 static void TestFileCopy()
 661 {
 662     wxPuts(_T("*** Testing wxCopyFile ***"));
 663
 664     static const wxChar *filename1 = _T("testdata.fc");
 665     static const wxChar *filename2 = _T("test2");
 666     if ( !wxCopyFile(filename1, filename2) )
 667     {
 668         wxPuts(_T("ERROR: failed to copy file"));
 669     }
 670     else
 671     {
 672         wxFFile f1(filename1, _T("rb")),
 673                 f2(filename2, _T("rb"));
 674
 675         if ( !f1.IsOpened() || !f2.IsOpened() )
 676         {
 677             wxPuts(_T("ERROR: failed to open file(s)"));
 678         }
 679         else
 680         {
 681             wxString s1, s2;
 682             if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
 683             {
 684                 wxPuts(_T("ERROR: failed to read file(s)"));
 685             }
 686             else
 687             {
 688                 if ( (s1.length() != s2.length()) ||
 689                      (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
 690                 {
 691                     wxPuts(_T("ERROR: copy error!"));
 692                 }
 693                 else
 694                 {
 695                     wxPuts(_T("File was copied ok."));
 696                 }
 697             }
 698         }
 699     }
 700
 701     if ( !wxRemoveFile(filename2) )
 702     {
 703         wxPuts(_T("ERROR: failed to remove the file"));
 704     }
 705
 706     wxPuts(wxEmptyString);
 707 }
 708
 709 static void TestTempFile()
 710 {
 711     wxPuts(_T("*** wxTempFile test ***"));
 712
 713     wxTempFile tmpFile;
 714     if ( tmpFile.Open(_T("test2")) && tmpFile.Write(_T("the answer is 42")) )
 715     {
 716         if ( tmpFile.Commit() )
 717             wxPuts(_T("File committed."));
 718         else
 719             wxPuts(_T("ERROR: could't commit temp file."));
 720
 721         wxRemoveFile(_T("test2"));
 722     }
 723
 724     wxPuts(wxEmptyString);
 725 }
 726
 727 #endif // TEST_FILE
 728
 729 // ----------------------------------------------------------------------------
 730 // wxFileConfig
 731 // ----------------------------------------------------------------------------
 732
 733 #ifdef TEST_FILECONF
 734
 735 #include "wx/confbase.h"
 736 #include "wx/fileconf.h"
 737
 738 static const struct FileConfTestData
 739 {
 740     const wxChar *name;      // value name
 741     const wxChar *value;     // the value from the file
 742 } fcTestData[] =
 743 {
 744     { _T("value1"),                       _T("one") },
 745     { _T("value2"),                       _T("two") },
 746     { _T("novalue"),                      _T("default") },
 747 };
 748
 749 static void TestFileConfRead()
 750 {
 751     wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
 752
 753     wxFileConfig fileconf(_T("test"), wxEmptyString,
 754                           _T("testdata.fc"), wxEmptyString,
 755                           wxCONFIG_USE_RELATIVE_PATH);
 756
 757     // test simple reading
 758     wxPuts(_T("\nReading config file:"));
 759     wxString defValue(_T("default")), value;
 760     for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
 761     {
 762         const FileConfTestData& data = fcTestData[n];
 763         value = fileconf.Read(data.name, defValue);
 764         wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
 765         if ( value == data.value )
 766         {
 767             wxPuts(_T("(ok)"));
 768         }
 769         else
 770         {
 771             wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
 772         }
 773     }
 774
 775     // test enumerating the entries
 776     wxPuts(_T("\nEnumerating all root entries:"));
 777     long dummy;
 778     wxString name;
 779     bool cont = fileconf.GetFirstEntry(name, dummy);
 780     while ( cont )
 781     {
 782         wxPrintf(_T("\t%s = %s\n"),
 783                name.c_str(),
 784                fileconf.Read(name.c_str(), _T("ERROR")).c_str());
 785
 786         cont = fileconf.GetNextEntry(name, dummy);
 787     }
 788
 789     static const wxChar *testEntry = _T("TestEntry");
 790     wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
 791     fileconf.Write(testEntry, _T("A value"));
 792     fileconf.DeleteEntry(testEntry);
 793     wxPrintf(fileconf.HasEntry(testEntry) ? _T("ERROR\n") : _T("ok\n"));
 794 }
 795
 796 #endif // TEST_FILECONF
 797
 798 // ----------------------------------------------------------------------------
 799 // wxFileName
 800 // ----------------------------------------------------------------------------
 801
 802 #ifdef TEST_FILENAME
 803
 804 #include "wx/filename.h"
 805
 806 #if 0
 807 static void DumpFileName(const wxChar *desc, const wxFileName& fn)
 808 {
 809     wxPuts(desc);
 810
 811     wxString full = fn.GetFullPath();
 812
 813     wxString vol, path, name, ext;
 814     wxFileName::SplitPath(full, &vol, &path, &name, &ext);
 815
 816     wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
 817              full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
 818
 819     wxFileName::SplitPath(full, &path, &name, &ext);
 820     wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
 821              path.c_str(), name.c_str(), ext.c_str());
 822
 823     wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
 824     wxPrintf(_T("with volume: \t'%s'\n"),
 825              fn.GetPath(wxPATH_GET_VOLUME).c_str());
 826     wxPrintf(_T("with separator:\t'%s'\n"),
 827              fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
 828     wxPrintf(_T("with both:   \t'%s'\n"),
 829              fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
 830
 831     wxPuts(_T("The directories in the path are:"));
 832     wxArrayString dirs = fn.GetDirs();
 833     size_t count = dirs.GetCount();
 834     for ( size_t n = 0; n < count; n++ )
 835     {
 836         wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
 837     }
 838 }
 839 #endif
 840
 841 static void TestFileNameTemp()
 842 {
 843     wxPuts(_T("*** testing wxFileName temp file creation ***"));
 844
 845     static const wxChar *tmpprefixes[] =
 846     {
 847         _T(""),
 848         _T("foo"),
 849         _T(".."),
 850         _T("../bar"),
 851 #ifdef __UNIX__
 852         _T("/tmp/foo"),
 853         _T("/tmp/foo/bar"), // this one must be an error
 854 #endif // __UNIX__
 855     };
 856
 857     for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
 858     {
 859         wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
 860         if ( path.empty() )
 861         {
 862             // "error" is not in upper case because it may be ok
 863             wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
 864         }
 865         else
 866         {
 867             wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
 868                    tmpprefixes[n], path.c_str());
 869
 870             if ( !wxRemoveFile(path) )
 871             {
 872                 wxLogWarning(_T("Failed to remove temp file '%s'"),
 873                              path.c_str());
 874             }
 875         }
 876     }
 877 }
 878
 879 static void TestFileNameDirManip()
 880 {
 881     // TODO: test AppendDir(), RemoveDir(), ...
 882 }
 883
 884 static void TestFileNameComparison()
 885 {
 886     // TODO!
 887 }
 888
 889 static void TestFileNameOperations()
 890 {
 891     // TODO!
 892 }
 893
 894 static void TestFileNameCwd()
 895 {
 896     // TODO!
 897 }
 898
 899 #endif // TEST_FILENAME
 900
 901 // ----------------------------------------------------------------------------
 902 // wxFileName time functions
 903 // ----------------------------------------------------------------------------
 904
 905 #ifdef TEST_FILETIME
 906
 907 #include "wx/filename.h"
 908 #include "wx/datetime.h"
 909
 910 static void TestFileGetTimes()
 911 {
 912     wxFileName fn(_T("testdata.fc"));
 913
 914     wxDateTime dtAccess, dtMod, dtCreate;
 915     if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
 916     {
 917         wxPrintf(_T("ERROR: GetTimes() failed.\n"));
 918     }
 919     else
 920     {
 921         static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
 922
 923         wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
 924         wxPrintf(_T("Creation:    \t%s\n"), dtCreate.Format(fmt).c_str());
 925         wxPrintf(_T("Last read:   \t%s\n"), dtAccess.Format(fmt).c_str());
 926         wxPrintf(_T("Last write:  \t%s\n"), dtMod.Format(fmt).c_str());
 927     }
 928 }
 929
 930 #if 0
 931 static void TestFileSetTimes()
 932 {
 933     wxFileName fn(_T("testdata.fc"));
 934
 935     if ( !fn.Touch() )
 936     {
 937         wxPrintf(_T("ERROR: Touch() failed.\n"));
 938     }
 939 }
 940 #endif
 941
 942 #endif // TEST_FILETIME
 943
 944 // ----------------------------------------------------------------------------
 945 // wxLocale
 946 // ----------------------------------------------------------------------------
 947
 948 #ifdef TEST_LOCALE
 949
 950 #include "wx/intl.h"
 951 #include "wx/utils.h"   // for wxSetEnv
 952
 953 static wxLocale gs_localeDefault;
 954     // NOTE: don't init it here as it needs a wxAppTraits object
 955     //       and thus must be init-ed after creation of the wxInitializer
 956     //       class in the main()
 957
 958 // find the name of the language from its value
 959 static const wxChar *GetLangName(int lang)
 960 {
 961     static const wxChar *languageNames[] =
 962     {
 963         _T("DEFAULT"),
 964         _T("UNKNOWN"),
 965         _T("ABKHAZIAN"),
 966         _T("AFAR"),
 967         _T("AFRIKAANS"),
 968         _T("ALBANIAN"),
 969         _T("AMHARIC"),
 970         _T("ARABIC"),
 971         _T("ARABIC_ALGERIA"),
 972         _T("ARABIC_BAHRAIN"),
 973         _T("ARABIC_EGYPT"),
 974         _T("ARABIC_IRAQ"),
 975         _T("ARABIC_JORDAN"),
 976         _T("ARABIC_KUWAIT"),
 977         _T("ARABIC_LEBANON"),
 978         _T("ARABIC_LIBYA"),
 979         _T("ARABIC_MOROCCO"),
 980         _T("ARABIC_OMAN"),
 981         _T("ARABIC_QATAR"),
 982         _T("ARABIC_SAUDI_ARABIA"),
 983         _T("ARABIC_SUDAN"),
 984         _T("ARABIC_SYRIA"),
 985         _T("ARABIC_TUNISIA"),
 986         _T("ARABIC_UAE"),
 987         _T("ARABIC_YEMEN"),
 988         _T("ARMENIAN"),
 989         _T("ASSAMESE"),
 990         _T("AYMARA"),
 991         _T("AZERI"),
 992         _T("AZERI_CYRILLIC"),
 993         _T("AZERI_LATIN"),
 994         _T("BASHKIR"),
 995         _T("BASQUE"),
 996         _T("BELARUSIAN"),
 997         _T("BENGALI"),
 998         _T("BHUTANI"),
 999         _T("BIHARI"),
1000         _T("BISLAMA"),
1001         _T("BRETON"),
1002         _T("BULGARIAN"),
1003         _T("BURMESE"),
1004         _T("CAMBODIAN"),
1005         _T("CATALAN"),
1006         _T("CHINESE"),
1007         _T("CHINESE_SIMPLIFIED"),
1008         _T("CHINESE_TRADITIONAL"),
1009         _T("CHINESE_HONGKONG"),
1010         _T("CHINESE_MACAU"),
1011         _T("CHINESE_SINGAPORE"),
1012         _T("CHINESE_TAIWAN"),
1013         _T("CORSICAN"),
1014         _T("CROATIAN"),
1015         _T("CZECH"),
1016         _T("DANISH"),
1017         _T("DUTCH"),
1018         _T("DUTCH_BELGIAN"),
1019         _T("ENGLISH"),
1020         _T("ENGLISH_UK"),
1021         _T("ENGLISH_US"),
1022         _T("ENGLISH_AUSTRALIA"),
1023         _T("ENGLISH_BELIZE"),
1024         _T("ENGLISH_BOTSWANA"),
1025         _T("ENGLISH_CANADA"),
1026         _T("ENGLISH_CARIBBEAN"),
1027         _T("ENGLISH_DENMARK"),
1028         _T("ENGLISH_EIRE"),
1029         _T("ENGLISH_JAMAICA"),
1030         _T("ENGLISH_NEW_ZEALAND"),
1031         _T("ENGLISH_PHILIPPINES"),
1032         _T("ENGLISH_SOUTH_AFRICA"),
1033         _T("ENGLISH_TRINIDAD"),
1034         _T("ENGLISH_ZIMBABWE"),
1035         _T("ESPERANTO"),
1036         _T("ESTONIAN"),
1037         _T("FAEROESE"),
1038         _T("FARSI"),
1039         _T("FIJI"),
1040         _T("FINNISH"),
1041         _T("FRENCH"),
1042         _T("FRENCH_BELGIAN"),
1043         _T("FRENCH_CANADIAN"),
1044         _T("FRENCH_LUXEMBOURG"),
1045         _T("FRENCH_MONACO"),
1046         _T("FRENCH_SWISS"),
1047         _T("FRISIAN"),
1048         _T("GALICIAN"),
1049         _T("GEORGIAN"),
1050         _T("GERMAN"),
1051         _T("GERMAN_AUSTRIAN"),
1052         _T("GERMAN_BELGIUM"),
1053         _T("GERMAN_LIECHTENSTEIN"),
1054         _T("GERMAN_LUXEMBOURG"),
1055         _T("GERMAN_SWISS"),
1056         _T("GREEK"),
1057         _T("GREENLANDIC"),
1058         _T("GUARANI"),
1059         _T("GUJARATI"),
1060         _T("HAUSA"),
1061         _T("HEBREW"),
1062         _T("HINDI"),
1063         _T("HUNGARIAN"),
1064         _T("ICELANDIC"),
1065         _T("INDONESIAN"),
1066         _T("INTERLINGUA"),
1067         _T("INTERLINGUE"),
1068         _T("INUKTITUT"),
1069         _T("INUPIAK"),
1070         _T("IRISH"),
1071         _T("ITALIAN"),
1072         _T("ITALIAN_SWISS"),
1073         _T("JAPANESE"),
1074         _T("JAVANESE"),
1075         _T("KANNADA"),
1076         _T("KASHMIRI"),
1077         _T("KASHMIRI_INDIA"),
1078         _T("KAZAKH"),
1079         _T("KERNEWEK"),
1080         _T("KINYARWANDA"),
1081         _T("KIRGHIZ"),
1082         _T("KIRUNDI"),
1083         _T("KONKANI"),
1084         _T("KOREAN"),
1085         _T("KURDISH"),
1086         _T("LAOTHIAN"),
1087         _T("LATIN"),
1088         _T("LATVIAN"),
1089         _T("LINGALA"),
1090         _T("LITHUANIAN"),
1091         _T("MACEDONIAN"),
1092         _T("MALAGASY"),
1093         _T("MALAY"),
1094         _T("MALAYALAM"),
1095         _T("MALAY_BRUNEI_DARUSSALAM"),
1096         _T("MALAY_MALAYSIA"),
1097         _T("MALTESE"),
1098         _T("MANIPURI"),
1099         _T("MAORI"),
1100         _T("MARATHI"),
1101         _T("MOLDAVIAN"),
1102         _T("MONGOLIAN"),
1103         _T("NAURU"),
1104         _T("NEPALI"),
1105         _T("NEPALI_INDIA"),
1106         _T("NORWEGIAN_BOKMAL"),
1107         _T("NORWEGIAN_NYNORSK"),
1108         _T("OCCITAN"),
1109         _T("ORIYA"),
1110         _T("OROMO"),
1111         _T("PASHTO"),
1112         _T("POLISH"),
1113         _T("PORTUGUESE"),
1114         _T("PORTUGUESE_BRAZILIAN"),
1115         _T("PUNJABI"),
1116         _T("QUECHUA"),
1117         _T("RHAETO_ROMANCE"),
1118         _T("ROMANIAN"),
1119         _T("RUSSIAN"),
1120         _T("RUSSIAN_UKRAINE"),
1121         _T("SAMOAN"),
1122         _T("SANGHO"),
1123         _T("SANSKRIT"),
1124         _T("SCOTS_GAELIC"),
1125         _T("SERBIAN"),
1126         _T("SERBIAN_CYRILLIC"),
1127         _T("SERBIAN_LATIN"),
1128         _T("SERBO_CROATIAN"),
1129         _T("SESOTHO"),
1130         _T("SETSWANA"),
1131         _T("SHONA"),
1132         _T("SINDHI"),
1133         _T("SINHALESE"),
1134         _T("SISWATI"),
1135         _T("SLOVAK"),
1136         _T("SLOVENIAN"),
1137         _T("SOMALI"),
1138         _T("SPANISH"),
1139         _T("SPANISH_ARGENTINA"),
1140         _T("SPANISH_BOLIVIA"),
1141         _T("SPANISH_CHILE"),
1142         _T("SPANISH_COLOMBIA"),
1143         _T("SPANISH_COSTA_RICA"),
1144         _T("SPANISH_DOMINICAN_REPUBLIC"),
1145         _T("SPANISH_ECUADOR"),
1146         _T("SPANISH_EL_SALVADOR"),
1147         _T("SPANISH_GUATEMALA"),
1148         _T("SPANISH_HONDURAS"),
1149         _T("SPANISH_MEXICAN"),
1150         _T("SPANISH_MODERN"),
1151         _T("SPANISH_NICARAGUA"),
1152         _T("SPANISH_PANAMA"),
1153         _T("SPANISH_PARAGUAY"),
1154         _T("SPANISH_PERU"),
1155         _T("SPANISH_PUERTO_RICO"),
1156         _T("SPANISH_URUGUAY"),
1157         _T("SPANISH_US"),
1158         _T("SPANISH_VENEZUELA"),
1159         _T("SUNDANESE"),
1160         _T("SWAHILI"),
1161         _T("SWEDISH"),
1162         _T("SWEDISH_FINLAND"),
1163         _T("TAGALOG"),
1164         _T("TAJIK"),
1165         _T("TAMIL"),
1166         _T("TATAR"),
1167         _T("TELUGU"),
1168         _T("THAI"),
1169         _T("TIBETAN"),
1170         _T("TIGRINYA"),
1171         _T("TONGA"),
1172         _T("TSONGA"),
1173         _T("TURKISH"),
1174         _T("TURKMEN"),
1175         _T("TWI"),
1176         _T("UIGHUR"),
1177         _T("UKRAINIAN"),
1178         _T("URDU"),
1179         _T("URDU_INDIA"),
1180         _T("URDU_PAKISTAN"),
1181         _T("UZBEK"),
1182         _T("UZBEK_CYRILLIC"),
1183         _T("UZBEK_LATIN"),
1184         _T("VIETNAMESE"),
1185         _T("VOLAPUK"),
1186         _T("WELSH"),
1187         _T("WOLOF"),
1188         _T("XHOSA"),
1189         _T("YIDDISH"),
1190         _T("YORUBA"),
1191         _T("ZHUANG"),
1192         _T("ZULU"),
1193     };
1194
1195     if ( (size_t)lang < WXSIZEOF(languageNames) )
1196         return languageNames[lang];
1197     else
1198         return _T("INVALID");
1199 }
1200
1201 static void TestDefaultLang()
1202 {
1203     wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
1204
1205     gs_localeDefault.Init(wxLANGUAGE_ENGLISH);
1206
1207     static const wxChar *langStrings[] =
1208     {
1209         NULL,               // system default
1210         _T("C"),
1211         _T("fr"),
1212         _T("fr_FR"),
1213         _T("en"),
1214         _T("en_GB"),
1215         _T("en_US"),
1216         _T("de_DE.iso88591"),
1217         _T("german"),
1218         _T("?"),            // invalid lang spec
1219         _T("klingonese"),   // I bet on some systems it does exist...
1220     };
1221
1222     wxPrintf(_T("The default system encoding is %s (%d)\n"),
1223              wxLocale::GetSystemEncodingName().c_str(),
1224              wxLocale::GetSystemEncoding());
1225
1226     for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1227     {
1228         const wxChar *langStr = langStrings[n];
1229         if ( langStr )
1230         {
1231             // FIXME: this doesn't do anything at all under Windows, we need
1232             //        to create a new wxLocale!
1233             wxSetEnv(_T("LC_ALL"), langStr);
1234         }
1235
1236         int lang = gs_localeDefault.GetSystemLanguage();
1237         wxPrintf(_T("Locale for '%s' is %s.\n"),
1238                  langStr ? langStr : _T("system default"), GetLangName(lang));
1239     }
1240 }
1241
1242 #endif // TEST_LOCALE
1243
1244 // ----------------------------------------------------------------------------
1245 // MIME types
1246 // ----------------------------------------------------------------------------
1247
1248 #ifdef TEST_MIME
1249
1250 #include "wx/mimetype.h"
1251
1252 static void TestMimeEnum()
1253 {
1254     wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1255
1256     wxArrayString mimetypes;
1257
1258     size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1259
1260     wxPrintf(_T("*** All %u known filetypes: ***\n"), count);
1261
1262     wxArrayString exts;
1263     wxString desc;
1264
1265     for ( size_t n = 0; n < count; n++ )
1266     {
1267         wxFileType *filetype =
1268             wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1269         if ( !filetype )
1270         {
1271             wxPrintf(_T("nothing known about the filetype '%s'!\n"),
1272                    mimetypes[n].c_str());
1273             continue;
1274         }
1275
1276         filetype->GetDescription(&desc);
1277         filetype->GetExtensions(exts);
1278
1279         filetype->GetIcon(NULL);
1280
1281         wxString extsAll;
1282         for ( size_t e = 0; e < exts.GetCount(); e++ )
1283         {
1284             if ( e > 0 )
1285                 extsAll << _T(", ");
1286             extsAll += exts[e];
1287         }
1288
1289         wxPrintf(_T("\t%s: %s (%s)\n"),
1290                mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1291     }
1292
1293     wxPuts(wxEmptyString);
1294 }
1295
1296 static void TestMimeFilename()
1297 {
1298     wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1299
1300     static const wxChar *filenames[] =
1301     {
1302         _T("readme.txt"),
1303         _T("document.pdf"),
1304         _T("image.gif"),
1305         _T("picture.jpeg"),
1306     };
1307
1308     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1309     {
1310         const wxString fname = filenames[n];
1311         wxString ext = fname.AfterLast(_T('.'));
1312         wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1313         if ( !ft )
1314         {
1315             wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1316         }
1317         else
1318         {
1319             wxString desc;
1320             if ( !ft->GetDescription(&desc) )
1321                 desc = _T("<no description>");
1322
1323             wxString cmd;
1324             if ( !ft->GetOpenCommand(&cmd,
1325                                      wxFileType::MessageParameters(fname, wxEmptyString)) )
1326                 cmd = _T("<no command available>");
1327             else
1328                 cmd = wxString(_T('"')) + cmd + _T('"');
1329
1330             wxPrintf(_T("To open %s (%s) do %s.\n"),
1331                      fname.c_str(), desc.c_str(), cmd.c_str());
1332
1333             delete ft;
1334         }
1335     }
1336
1337     wxPuts(wxEmptyString);
1338 }
1339
1340 // these tests were broken by wxMimeTypesManager changes, temporarily disabling
1341 #if 0
1342
1343 static void TestMimeOverride()
1344 {
1345     wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1346
1347     static const wxChar *mailcap = _T("/tmp/mailcap");
1348     static const wxChar *mimetypes = _T("/tmp/mime.types");
1349
1350     if ( wxFile::Exists(mailcap) )
1351         wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1352                  mailcap,
1353                  wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
1354     else
1355         wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1356                  mailcap);
1357
1358     if ( wxFile::Exists(mimetypes) )
1359         wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1360                  mimetypes,
1361                  wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
1362     else
1363         wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1364                  mimetypes);
1365
1366     wxPuts(wxEmptyString);
1367 }
1368
1369 static void TestMimeAssociate()
1370 {
1371     wxPuts(_T("*** Testing creation of filetype association ***\n"));
1372
1373     wxFileTypeInfo ftInfo(
1374                             _T("application/x-xyz"),
1375                             _T("xyzview '%s'"), // open cmd
1376                             _T(""),             // print cmd
1377                             _T("XYZ File"),     // description
1378                             _T(".xyz"),         // extensions
1379                             wxNullPtr           // end of extensions
1380                          );
1381     ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1382
1383     wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1384     if ( !ft )
1385     {
1386         wxPuts(_T("ERROR: failed to create association!"));
1387     }
1388     else
1389     {
1390         // TODO: read it back
1391         delete ft;
1392     }
1393
1394     wxPuts(wxEmptyString);
1395 }
1396
1397 #endif // 0
1398
1399 #endif // TEST_MIME
1400
1401 // ----------------------------------------------------------------------------
1402 // module dependencies feature
1403 // ----------------------------------------------------------------------------
1404
1405 #ifdef TEST_MODULE
1406
1407 #include "wx/module.h"
1408
1409 class wxTestModule : public wxModule
1410 {
1411 protected:
1412     virtual bool OnInit() { wxPrintf(_T("Load module: %s\n"), GetClassInfo()->GetClassName()); return true; }
1413     virtual void OnExit() { wxPrintf(_T("Unload module: %s\n"), GetClassInfo()->GetClassName()); }
1414 };
1415
1416 class wxTestModuleA : public wxTestModule
1417 {
1418 public:
1419     wxTestModuleA();
1420 private:
1421     DECLARE_DYNAMIC_CLASS(wxTestModuleA)
1422 };
1423
1424 class wxTestModuleB : public wxTestModule
1425 {
1426 public:
1427     wxTestModuleB();
1428 private:
1429     DECLARE_DYNAMIC_CLASS(wxTestModuleB)
1430 };
1431
1432 class wxTestModuleC : public wxTestModule
1433 {
1434 public:
1435     wxTestModuleC();
1436 private:
1437     DECLARE_DYNAMIC_CLASS(wxTestModuleC)
1438 };
1439
1440 class wxTestModuleD : public wxTestModule
1441 {
1442 public:
1443     wxTestModuleD();
1444 private:
1445     DECLARE_DYNAMIC_CLASS(wxTestModuleD)
1446 };
1447
1448 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleC, wxModule)
1449 wxTestModuleC::wxTestModuleC()
1450 {
1451     AddDependency(CLASSINFO(wxTestModuleD));
1452 }
1453
1454 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleA, wxModule)
1455 wxTestModuleA::wxTestModuleA()
1456 {
1457     AddDependency(CLASSINFO(wxTestModuleB));
1458     AddDependency(CLASSINFO(wxTestModuleD));
1459 }
1460
1461 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleD, wxModule)
1462 wxTestModuleD::wxTestModuleD()
1463 {
1464 }
1465
1466 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleB, wxModule)
1467 wxTestModuleB::wxTestModuleB()
1468 {
1469     AddDependency(CLASSINFO(wxTestModuleD));
1470     AddDependency(CLASSINFO(wxTestModuleC));
1471 }
1472
1473 #endif // TEST_MODULE
1474
1475 // ----------------------------------------------------------------------------
1476 // misc information functions
1477 // ----------------------------------------------------------------------------
1478
1479 #ifdef TEST_INFO_FUNCTIONS
1480
1481 #include "wx/utils.h"
1482
1483 #if TEST_INTERACTIVE
1484 static void TestDiskInfo()
1485 {
1486     wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
1487
1488     for ( ;; )
1489     {
1490         wxChar pathname[128];
1491         wxPrintf(_T("\nEnter a directory name: "));
1492         if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
1493             break;
1494
1495         // kill the last '\n'
1496         pathname[wxStrlen(pathname) - 1] = 0;
1497
1498         wxLongLong total, free;
1499         if ( !wxGetDiskSpace(pathname, &total, &free) )
1500         {
1501             wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1502         }
1503         else
1504         {
1505             wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1506                     (total / 1024).ToString().c_str(),
1507                     (free / 1024).ToString().c_str(),
1508                     pathname);
1509         }
1510     }
1511 }
1512 #endif // TEST_INTERACTIVE
1513
1514 static void TestOsInfo()
1515 {
1516     wxPuts(_T("*** Testing OS info functions ***\n"));
1517
1518     int major, minor;
1519     wxGetOsVersion(&major, &minor);
1520     wxPrintf(_T("Running under: %s, version %d.%d\n"),
1521             wxGetOsDescription().c_str(), major, minor);
1522
1523     wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());
1524
1525     wxPrintf(_T("Host name is %s (%s).\n"),
1526            wxGetHostName().c_str(), wxGetFullHostName().c_str());
1527
1528     wxPuts(wxEmptyString);
1529 }
1530
1531 static void TestPlatformInfo()
1532 {
1533     wxPuts(_T("*** Testing wxPlatformInfo functions ***\n"));
1534
1535     // get this platform
1536     wxPlatformInfo plat;
1537
1538     wxPrintf(_T("Operating system family name is: %s\n"), plat.GetOperatingSystemFamilyName().c_str());
1539     wxPrintf(_T("Operating system name is: %s\n"), plat.GetOperatingSystemIdName().c_str());
1540     wxPrintf(_T("Port ID name is: %s\n"), plat.GetPortIdName().c_str());
1541     wxPrintf(_T("Port ID short name is: %s\n"), plat.GetPortIdShortName().c_str());
1542     wxPrintf(_T("Architecture is: %s\n"), plat.GetArchName().c_str());
1543     wxPrintf(_T("Endianness is: %s\n"), plat.GetEndiannessName().c_str());
1544
1545     wxPuts(wxEmptyString);
1546 }
1547
1548 static void TestUserInfo()
1549 {
1550     wxPuts(_T("*** Testing user info functions ***\n"));
1551
1552     wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
1553     wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
1554     wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
1555     wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
1556
1557     wxPuts(wxEmptyString);
1558 }
1559
1560 #endif // TEST_INFO_FUNCTIONS
1561
1562 // ----------------------------------------------------------------------------
1563 // path list
1564 // ----------------------------------------------------------------------------
1565
1566 #ifdef TEST_PATHLIST
1567
1568 #ifdef __UNIX__
1569     #define CMD_IN_PATH _T("ls")
1570 #else
1571     #define CMD_IN_PATH _T("command.com")
1572 #endif
1573
1574 static void TestPathList()
1575 {
1576     wxPuts(_T("*** Testing wxPathList ***\n"));
1577
1578     wxPathList pathlist;
1579     pathlist.AddEnvList(_T("PATH"));
1580     wxString path = pathlist.FindValidPath(CMD_IN_PATH);
1581     if ( path.empty() )
1582     {
1583         wxPrintf(_T("ERROR: command not found in the path.\n"));
1584     }
1585     else
1586     {
1587         wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
1588     }
1589 }
1590
1591 #endif // TEST_PATHLIST
1592
1593 // ----------------------------------------------------------------------------
1594 // regular expressions
1595 // ----------------------------------------------------------------------------
1596
1597 #if defined TEST_REGEX && TEST_INTERACTIVE
1598
1599 #include "wx/regex.h"
1600
1601 static void TestRegExInteractive()
1602 {
1603     wxPuts(_T("*** Testing RE interactively ***"));
1604
1605     for ( ;; )
1606     {
1607         wxChar pattern[128];
1608         wxPrintf(_T("\nEnter a pattern: "));
1609         if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
1610             break;
1611
1612         // kill the last '\n'
1613         pattern[wxStrlen(pattern) - 1] = 0;
1614
1615         wxRegEx re;
1616         if ( !re.Compile(pattern) )
1617         {
1618             continue;
1619         }
1620
1621         wxChar text[128];
1622         for ( ;; )
1623         {
1624             wxPrintf(_T("Enter text to match: "));
1625             if ( !wxFgets(text, WXSIZEOF(text), stdin) )
1626                 break;
1627
1628             // kill the last '\n'
1629             text[wxStrlen(text) - 1] = 0;
1630
1631             if ( !re.Matches(text) )
1632             {
1633                 wxPrintf(_T("No match.\n"));
1634             }
1635             else
1636             {
1637                 wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
1638
1639                 size_t start, len;
1640                 for ( size_t n = 1; ; n++ )
1641                 {
1642                     if ( !re.GetMatch(&start, &len, n) )
1643                     {
1644                         break;
1645                     }
1646
1647                     wxPrintf(_T("Subexpr %u matched '%s'\n"),
1648                              n, wxString(text + start, len).c_str());
1649                 }
1650             }
1651         }
1652     }
1653 }
1654
1655 #endif // TEST_REGEX
1656
1657 // ----------------------------------------------------------------------------
1658 // printf() tests
1659 // ----------------------------------------------------------------------------
1660
1661 /*
1662    NB: this stuff was taken from the glibc test suite and modified to build
1663        in wxWidgets: if I read the copyright below properly, this shouldn't
1664        be a problem
1665  */
1666
1667 #ifdef TEST_PRINTF
1668
1669 #ifdef wxTEST_PRINTF
1670     // use our functions from wxchar.cpp
1671     #undef wxPrintf
1672     #undef wxSprintf
1673
1674     // NB: do _not_ use WX_ATTRIBUTE_PRINTF here, we have some invalid formats
1675     //     in the tests below
1676     int wxPrintf( const wxChar *format, ... );
1677     int wxSprintf( wxChar *str, const wxChar *format, ... );
1678 #endif
1679
1680 #include "wx/longlong.h"
1681
1682 #include <float.h>
1683
1684 static void rfg1 (void);
1685 static void rfg2 (void);
1686
1687
1688 static void
1689 fmtchk (const wxChar *fmt)
1690 {
1691   (void) wxPrintf(_T("%s:\t`"), fmt);
1692   (void) wxPrintf(fmt, 0x12);
1693   (void) wxPrintf(_T("'\n"));
1694 }
1695
1696 static void
1697 fmtst1chk (const wxChar *fmt)
1698 {
1699   (void) wxPrintf(_T("%s:\t`"), fmt);
1700   (void) wxPrintf(fmt, 4, 0x12);
1701   (void) wxPrintf(_T("'\n"));
1702 }
1703
1704 static void
1705 fmtst2chk (const wxChar *fmt)
1706 {
1707   (void) wxPrintf(_T("%s:\t`"), fmt);
1708   (void) wxPrintf(fmt, 4, 4, 0x12);
1709   (void) wxPrintf(_T("'\n"));
1710 }
1711
1712 /* This page is covered by the following copyright: */
1713
1714 /* (C) Copyright C E Chew
1715  *
1716  * Feel free to copy, use and distribute this software provided:
1717  *
1718  *        1. you do not pretend that you wrote it
1719  *        2. you leave this copyright notice intact.
1720  */
1721
1722 /*
1723  * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
1724  */
1725
1726 #define DEC -123
1727 #define INT 255
1728 #define UNS (~0)
1729
1730 /* Formatted Output Test
1731  *
1732  * This exercises the output formatting code.
1733  */
1734
1735 wxChar *PointerNull = NULL;
1736
1737 static void
1738 fp_test (void)
1739 {
1740   int i, j, k, l;
1741   wxChar buf[7];
1742   wxChar *prefix = buf;
1743   wxChar tp[20];
1744
1745   wxPuts(_T("\nFormatted output test"));
1746   wxPrintf(_T("prefix  6d      6o      6x      6X      6u\n"));
1747   wxStrcpy(prefix, _T("%"));
1748   for (i = 0; i < 2; i++) {
1749     for (j = 0; j < 2; j++) {
1750       for (k = 0; k < 2; k++) {
1751         for (l = 0; l < 2; l++) {
1752           wxStrcpy(prefix, _T("%"));
1753           if (i == 0) wxStrcat(prefix, _T("-"));
1754           if (j == 0) wxStrcat(prefix, _T("+"));
1755           if (k == 0) wxStrcat(prefix, _T("#"));
1756           if (l == 0) wxStrcat(prefix, _T("0"));
1757           wxPrintf(_T("%5s |"), prefix);
1758           wxStrcpy(tp, prefix);
1759           wxStrcat(tp, _T("6d |"));
1760           wxPrintf(tp, DEC);
1761           wxStrcpy(tp, prefix);
1762           wxStrcat(tp, _T("6o |"));
1763           wxPrintf(tp, INT);
1764           wxStrcpy(tp, prefix);
1765           wxStrcat(tp, _T("6x |"));
1766           wxPrintf(tp, INT);
1767           wxStrcpy(tp, prefix);
1768           wxStrcat(tp, _T("6X |"));
1769           wxPrintf(tp, INT);
1770           wxStrcpy(tp, prefix);
1771           wxStrcat(tp, _T("6u |"));
1772           wxPrintf(tp, UNS);
1773           wxPrintf(_T("\n"));
1774         }
1775       }
1776     }
1777   }
1778   wxPrintf(_T("%10s\n"), PointerNull);
1779   wxPrintf(_T("%-10s\n"), PointerNull);
1780 }
1781
1782 static void TestPrintf()
1783 {
1784   static wxChar shortstr[] = _T("Hi, Z.");
1785   static wxChar longstr[] = _T("Good morning, Doctor Chandra.  This is Hal.  \
1786 I am ready for my first lesson today.");
1787   int result = 0;
1788   wxString test_format;
1789
1790   fmtchk(_T("%.4x"));
1791   fmtchk(_T("%04x"));
1792   fmtchk(_T("%4.4x"));
1793   fmtchk(_T("%04.4x"));
1794   fmtchk(_T("%4.3x"));
1795   fmtchk(_T("%04.3x"));
1796
1797   fmtst1chk(_T("%.*x"));
1798   fmtst1chk(_T("%0*x"));
1799   fmtst2chk(_T("%*.*x"));
1800   fmtst2chk(_T("%0*.*x"));
1801
1802   wxString bad_format = _T("bad format:\t\"%b\"\n");
1803   wxPrintf(bad_format.c_str());
1804   wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
1805
1806   wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
1807   wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
1808   wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
1809   wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
1810   wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
1811   wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
1812   wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
1813   test_format = _T("left-adjusted ZLDN:\t\"%-010ld\"\n");
1814   wxPrintf(test_format.c_str(), -123456);
1815   wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
1816   wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
1817
1818   test_format = _T("zero-padded string:\t\"%010s\"\n");
1819   wxPrintf(test_format.c_str(), shortstr);
1820   test_format = _T("left-adjusted Z string:\t\"%-010s\"\n");
1821   wxPrintf(test_format.c_str(), shortstr);
1822   wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
1823   wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
1824   wxPrintf(_T("null string:\t\"%s\"\n"), PointerNull);
1825   wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr);
1826
1827   wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
1828   wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
1829   wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
1830   wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20);
1831   wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
1832   wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
1833   wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
1834   wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
1835   wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
1836   wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
1837   wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
1838   wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20);
1839
1840   wxPrintf (_T(" %6.5f\n"), .099999999860301614);
1841   wxPrintf (_T(" %6.5f\n"), .1);
1842   wxPrintf (_T("x%5.4fx\n"), .5);
1843
1844   wxPrintf (_T("%#03x\n"), 1);
1845
1846   //wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
1847
1848   {
1849     double d = FLT_MIN;
1850     int niter = 17;
1851
1852     while (niter-- != 0)
1853       wxPrintf (_T("%.17e\n"), d / 2);
1854     fflush (stdout);
1855   }
1856
1857 #ifndef __WATCOMC__
1858   // Open Watcom cause compiler error here
1859   // Error! E173: col(24) floating-point constant too small to represent
1860   wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
1861 #endif
1862
1863 #define FORMAT _T("|%12.4f|%12.4e|%12.4g|\n")
1864   wxPrintf (FORMAT, 0.0, 0.0, 0.0);
1865   wxPrintf (FORMAT, 1.0, 1.0, 1.0);
1866   wxPrintf (FORMAT, -1.0, -1.0, -1.0);
1867   wxPrintf (FORMAT, 100.0, 100.0, 100.0);
1868   wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
1869   wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
1870   wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
1871   wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
1872   wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
1873 #undef        FORMAT
1874
1875   {
1876     wxChar buf[20];
1877     int rc = wxSnprintf (buf, WXSIZEOF(buf), _T("%30s"), _T("foo"));
1878
1879     wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
1880              rc, WXSIZEOF(buf), buf);
1881 #if 0
1882     wxChar buf2[512];
1883     wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
1884             wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
1885 #endif
1886   }
1887
1888   fp_test ();
1889
1890   wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
1891   wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
1892   wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
1893   wxPrintf (_T("%g should be 123.456\n"), 123.456);
1894   wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
1895   wxPrintf (_T("%g should be 10\n"), 10.0);
1896   wxPrintf (_T("%g should be 0.02\n"), 0.02);
1897
1898   {
1899     double x=1.0;
1900     wxPrintf(_T("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
1901   }
1902
1903   {
1904     wxChar buf[200];
1905
1906     wxSprintf(buf,_T("%*s%*s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
1907
1908     result |= wxStrcmp (buf,
1909                       _T("onetwo                 three                         "));
1910
1911     wxPuts (result != 0 ? _T("Test failed!") : _T("Test ok."));
1912   }
1913
1914 #ifdef wxLongLong_t
1915   {
1916       wxChar buf[200];
1917
1918       wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
1919       #if 0
1920         // for some reason below line fails under Borland
1921       wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
1922       #endif
1923
1924       if (wxStrcmp (buf, _T("40000000000")) != 0)
1925       {
1926           result = 1;
1927           wxPuts (_T("\tFAILED"));
1928       }
1929       wxUnusedVar(result);
1930       wxPuts (wxEmptyString);
1931   }
1932 #endif // wxLongLong_t
1933
1934   wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
1935   wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
1936
1937   wxPuts (_T("--- Should be no further output. ---"));
1938   rfg1 ();
1939   rfg2 ();
1940
1941 #if 0
1942   {
1943     wxChar bytes[7];
1944     wxChar buf[20];
1945
1946     memset (bytes, '\xff', sizeof bytes);
1947     wxSprintf (buf, _T("foo%hhn\n"), &bytes[3]);
1948     if (bytes[0] != '\xff' || bytes[1] != '\xff' || bytes[2] != '\xff'
1949         || bytes[4] != '\xff' || bytes[5] != '\xff' || bytes[6] != '\xff')
1950       {
1951         wxPuts (_T("%hhn overwrite more bytes"));
1952         result = 1;
1953       }
1954     if (bytes[3] != 3)
1955       {
1956         wxPuts (_T("%hhn wrote incorrect value"));
1957         result = 1;
1958       }
1959   }
1960 #endif
1961 }
1962
1963 static void
1964 rfg1 (void)
1965 {
1966   wxChar buf[100];
1967
1968   wxSprintf (buf, _T("%5.s"), _T("xyz"));
1969   if (wxStrcmp (buf, _T("     ")) != 0)
1970     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("     "));
1971   wxSprintf (buf, _T("%5.f"), 33.3);
1972   if (wxStrcmp (buf, _T("   33")) != 0)
1973     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   33"));
1974   wxSprintf (buf, _T("%8.e"), 33.3e7);
1975   if (wxStrcmp (buf, _T("   3e+08")) != 0)
1976     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   3e+08"));
1977   wxSprintf (buf, _T("%8.E"), 33.3e7);
1978   if (wxStrcmp (buf, _T("   3E+08")) != 0)
1979     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   3E+08"));
1980   wxSprintf (buf, _T("%.g"), 33.3);
1981   if (wxStrcmp (buf, _T("3e+01")) != 0)
1982     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3e+01"));
1983   wxSprintf (buf, _T("%.G"), 33.3);
1984   if (wxStrcmp (buf, _T("3E+01")) != 0)
1985     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3E+01"));
1986 }
1987
1988 static void
1989 rfg2 (void)
1990 {
1991   int prec;
1992   wxChar buf[100];
1993   wxString test_format;
1994
1995   prec = 0;
1996   wxSprintf (buf, _T("%.*g"), prec, 3.3);
1997   if (wxStrcmp (buf, _T("3")) != 0)
1998     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
1999   prec = 0;
2000   wxSprintf (buf, _T("%.*G"), prec, 3.3);
2001   if (wxStrcmp (buf, _T("3")) != 0)
2002     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
2003   prec = 0;
2004   wxSprintf (buf, _T("%7.*G"), prec, 3.33);
2005   if (wxStrcmp (buf, _T("      3")) != 0)
2006     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("      3"));
2007   prec = 3;
2008   test_format = _T("%04.*o");
2009   wxSprintf (buf, test_format.c_str(), prec, 33);
2010   if (wxStrcmp (buf, _T(" 041")) != 0)
2011     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
2012   prec = 7;
2013   test_format = _T("%09.*u");
2014   wxSprintf (buf, test_format.c_str(), prec, 33);
2015   if (wxStrcmp (buf, _T("  0000033")) != 0)
2016     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("  0000033"));
2017   prec = 3;
2018   test_format = _T("%04.*x");
2019   wxSprintf (buf, test_format.c_str(), prec, 33);
2020   if (wxStrcmp (buf, _T(" 021")) != 0)
2021     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2022   prec = 3;
2023   test_format = _T("%04.*X");
2024   wxSprintf (buf, test_format.c_str(), prec, 33);
2025   if (wxStrcmp (buf, _T(" 021")) != 0)
2026     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2027 }
2028
2029 #endif // TEST_PRINTF
2030
2031 // ----------------------------------------------------------------------------
2032 // registry and related stuff
2033 // ----------------------------------------------------------------------------
2034
2035 // this is for MSW only
2036 #ifndef __WXMSW__
2037     #undef TEST_REGCONF
2038     #undef TEST_REGISTRY
2039 #endif
2040
2041 #ifdef TEST_REGCONF
2042
2043 #include "wx/confbase.h"
2044 #include "wx/msw/regconf.h"
2045
2046 #if 0
2047 static void TestRegConfWrite()
2048 {
2049     wxConfig *config = new wxConfig(_T("myapp"));
2050     config->SetPath(_T("/group1"));
2051     config->Write(_T("entry1"), _T("foo"));
2052     config->SetPath(_T("/group2"));
2053     config->Write(_T("entry1"), _T("bar"));
2054 }
2055 #endif
2056
2057 static void TestRegConfRead()
2058 {
2059     wxRegConfig *config = new wxRegConfig(_T("myapp"));
2060
2061     wxString str;
2062     long dummy;
2063     config->SetPath(_T("/"));
2064     wxPuts(_T("Enumerating / subgroups:"));
2065     bool bCont = config->GetFirstGroup(str, dummy);
2066     while(bCont)
2067     {
2068         wxPuts(str);
2069         bCont = config->GetNextGroup(str, dummy);
2070     }
2071 }
2072
2073 #endif // TEST_REGCONF
2074
2075 #ifdef TEST_REGISTRY
2076
2077 #include "wx/msw/registry.h"
2078
2079 // I chose this one because I liked its name, but it probably only exists under
2080 // NT
2081 static const wxChar *TESTKEY =
2082     _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2083
2084 static void TestRegistryRead()
2085 {
2086     wxPuts(_T("*** testing registry reading ***"));
2087
2088     wxRegKey key(TESTKEY);
2089     wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
2090     if ( !key.Open() )
2091     {
2092         wxPuts(_T("ERROR: test key can't be opened, aborting test."));
2093
2094         return;
2095     }
2096
2097     size_t nSubKeys, nValues;
2098     if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
2099     {
2100         wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
2101     }
2102
2103     wxPrintf(_T("Enumerating values:\n"));
2104
2105     long dummy;
2106     wxString value;
2107     bool cont = key.GetFirstValue(value, dummy);
2108     while ( cont )
2109     {
2110         wxPrintf(_T("Value '%s': type "), value.c_str());
2111         switch ( key.GetValueType(value) )
2112         {
2113             case wxRegKey::Type_None:   wxPrintf(_T("ERROR (none)")); break;
2114             case wxRegKey::Type_String: wxPrintf(_T("SZ")); break;
2115             case wxRegKey::Type_Expand_String: wxPrintf(_T("EXPAND_SZ")); break;
2116             case wxRegKey::Type_Binary: wxPrintf(_T("BINARY")); break;
2117             case wxRegKey::Type_Dword: wxPrintf(_T("DWORD")); break;
2118             case wxRegKey::Type_Multi_String: wxPrintf(_T("MULTI_SZ")); break;
2119             default: wxPrintf(_T("other (unknown)")); break;
2120         }
2121
2122         wxPrintf(_T(", value = "));
2123         if ( key.IsNumericValue(value) )
2124         {
2125             long val;
2126             key.QueryValue(value, &val);
2127             wxPrintf(_T("%ld"), val);
2128         }
2129         else // string
2130         {
2131             wxString val;
2132             key.QueryValue(value, val);
2133             wxPrintf(_T("'%s'"), val.c_str());
2134
2135             key.QueryRawValue(value, val);
2136             wxPrintf(_T(" (raw value '%s')"), val.c_str());
2137         }
2138
2139         wxPutchar('\n');
2140
2141         cont = key.GetNextValue(value, dummy);
2142     }
2143 }
2144
2145 static void TestRegistryAssociation()
2146 {
2147     /*
2148        The second call to deleteself genertaes an error message, with a
2149        messagebox saying .flo is crucial to system operation, while the .ddf
2150        call also fails, but with no error message
2151     */
2152
2153     wxRegKey key;
2154
2155     key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2156     key.Create();
2157     key = _T("ddxf_auto_file") ;
2158     key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2159     key.Create();
2160     key = _T("ddxf_auto_file") ;
2161     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2162     key.Create();
2163     key = _T("program,0") ;
2164     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2165     key.Create();
2166     key = _T("program \"%1\"") ;
2167
2168     key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2169     key.DeleteSelf();
2170     key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2171     key.DeleteSelf();
2172     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2173     key.DeleteSelf();
2174     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2175     key.DeleteSelf();
2176 }
2177
2178 #endif // TEST_REGISTRY
2179
2180 // ----------------------------------------------------------------------------
2181 // scope guard
2182 // ----------------------------------------------------------------------------
2183
2184 #ifdef TEST_SCOPEGUARD
2185
2186 #include "wx/scopeguard.h"
2187
2188 static void function0() { puts("function0()"); }
2189 static void function1(int n) { printf("function1(%d)\n", n); }
2190 static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
2191
2192 struct Object
2193 {
2194     void method0() { printf("method0()\n"); }
2195     void method1(int n) { printf("method1(%d)\n", n); }
2196     void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
2197 };
2198
2199 static void TestScopeGuard()
2200 {
2201     wxON_BLOCK_EXIT0(function0);
2202     wxON_BLOCK_EXIT1(function1, 17);
2203     wxON_BLOCK_EXIT2(function2, 3.14, 'p');
2204
2205     Object obj;
2206     wxON_BLOCK_EXIT_OBJ0(obj, Object::method0);
2207     wxON_BLOCK_EXIT_OBJ1(obj, Object::method1, 7);
2208     wxON_BLOCK_EXIT_OBJ2(obj, Object::method2, 2.71, 'e');
2209
2210     wxScopeGuard dismissed = wxMakeGuard(function0);
2211     dismissed.Dismiss();
2212 }
2213
2214 #endif
2215
2216 // ----------------------------------------------------------------------------
2217 // sockets
2218 // ----------------------------------------------------------------------------
2219
2220 #ifdef TEST_SOCKETS
2221
2222 #include "wx/socket.h"
2223 #include "wx/protocol/protocol.h"
2224 #include "wx/protocol/http.h"
2225
2226 static void TestSocketServer()
2227 {
2228     wxPuts(_T("*** Testing wxSocketServer ***\n"));
2229
2230     static const int PORT = 3000;
2231
2232     wxIPV4address addr;
2233     addr.Service(PORT);
2234
2235     wxSocketServer *server = new wxSocketServer(addr);
2236     if ( !server->Ok() )
2237     {
2238         wxPuts(_T("ERROR: failed to bind"));
2239
2240         return;
2241     }
2242
2243     bool quit = false;
2244     while ( !quit )
2245     {
2246         wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
2247
2248         wxSocketBase *socket = server->Accept();
2249         if ( !socket )
2250         {
2251             wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
2252             break;
2253         }
2254
2255         wxPuts(_T("Server: got a client."));
2256
2257         server->SetTimeout(60); // 1 min
2258
2259         bool close = false;
2260         while ( !close && socket->IsConnected() )
2261         {
2262             wxString s;
2263             wxChar ch = _T('\0');
2264             for ( ;; )
2265             {
2266                 if ( socket->Read(&ch, sizeof(ch)).Error() )
2267                 {
2268                     // don't log error if the client just close the connection
2269                     if ( socket->IsConnected() )
2270                     {
2271                         wxPuts(_T("ERROR: in wxSocket::Read."));
2272                     }
2273
2274                     break;
2275                 }
2276
2277                 if ( ch == '\r' )
2278                     continue;
2279
2280                 if ( ch == '\n' )
2281                     break;
2282
2283                 s += ch;
2284             }
2285
2286             if ( ch != '\n' )
2287             {
2288                 break;
2289             }
2290
2291             wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
2292             if ( s == _T("close") )
2293             {
2294                 wxPuts(_T("Closing connection"));
2295
2296                 close = true;
2297             }
2298             else if ( s == _T("quit") )
2299             {
2300                 close =
2301                 quit = true;
2302
2303                 wxPuts(_T("Shutting down the server"));
2304             }
2305             else // not a special command
2306             {
2307                 socket->Write(s.MakeUpper().c_str(), s.length());
2308                 socket->Write("\r\n", 2);
2309                 wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
2310             }
2311         }
2312
2313         if ( !close )
2314         {
2315             wxPuts(_T("Server: lost a client unexpectedly."));
2316         }
2317
2318         socket->Destroy();
2319     }
2320
2321     // same as "delete server" but is consistent with GUI programs
2322     server->Destroy();
2323 }
2324
2325 static void TestSocketClient()
2326 {
2327     wxPuts(_T("*** Testing wxSocketClient ***\n"));
2328
2329     static const wxChar *hostname = _T("www.wxwidgets.org");
2330
2331     wxIPV4address addr;
2332     addr.Hostname(hostname);
2333     addr.Service(80);
2334
2335     wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
2336
2337     wxSocketClient client;
2338     if ( !client.Connect(addr) )
2339     {
2340         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2341     }
2342     else
2343     {
2344         wxPrintf(_T("--- Connected to %s:%u...\n"),
2345                addr.Hostname().c_str(), addr.Service());
2346
2347         wxChar buf[8192];
2348
2349         // could use simply "GET" here I suppose
2350         wxString cmdGet =
2351             wxString::Format(_T("GET http://%s/\r\n"), hostname);
2352         client.Write(cmdGet, cmdGet.length());
2353         wxPrintf(_T("--- Sent command '%s' to the server\n"),
2354                MakePrintable(cmdGet).c_str());
2355         client.Read(buf, WXSIZEOF(buf));
2356         wxPrintf(_T("--- Server replied:\n%s"), buf);
2357     }
2358 }
2359
2360 #endif // TEST_SOCKETS
2361
2362 // ----------------------------------------------------------------------------
2363 // FTP
2364 // ----------------------------------------------------------------------------
2365
2366 #ifdef TEST_FTP
2367
2368 #include "wx/protocol/ftp.h"
2369 #include "wx/protocol/log.h"
2370
2371 #define FTP_ANONYMOUS
2372
2373 static wxFTP *ftp;
2374
2375 #ifdef FTP_ANONYMOUS
2376     static const wxChar *directory = _T("/pub");
2377     static const wxChar *filename = _T("welcome.msg");
2378 #else
2379     static const wxChar *directory = _T("/etc");
2380     static const wxChar *filename = _T("issue");
2381 #endif
2382
2383 static bool TestFtpConnect()
2384 {
2385     wxPuts(_T("*** Testing FTP connect ***"));
2386
2387 #ifdef FTP_ANONYMOUS
2388     static const wxChar *hostname = _T("ftp.wxwidgets.org");
2389
2390     wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
2391 #else // !FTP_ANONYMOUS
2392     static const wxChar *hostname = "localhost";
2393
2394     wxChar user[256];
2395     wxFgets(user, WXSIZEOF(user), stdin);
2396     user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
2397     ftp->SetUser(user);
2398
2399     wxChar password[256];
2400     wxPrintf(_T("Password for %s: "), password);
2401     wxFgets(password, WXSIZEOF(password), stdin);
2402     password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
2403     ftp->SetPassword(password);
2404
2405     wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
2406 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2407
2408     if ( !ftp->Connect(hostname) )
2409     {
2410         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2411
2412         return false;
2413     }
2414     else
2415     {
2416         wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
2417                  hostname, ftp->Pwd().c_str());
2418         ftp->Close();
2419     }
2420
2421     return true;
2422 }
2423
2424 static void TestFtpList()
2425 {
2426     wxPuts(_T("*** Testing wxFTP file listing ***\n"));
2427
2428     // test CWD
2429     if ( !ftp->ChDir(directory) )
2430     {
2431         wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
2432     }
2433
2434     wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2435
2436     // test NLIST and LIST
2437     wxArrayString files;
2438     if ( !ftp->GetFilesList(files) )
2439     {
2440         wxPuts(_T("ERROR: failed to get NLIST of files"));
2441     }
2442     else
2443     {
2444         wxPrintf(_T("Brief list of files under '%s':\n"), ftp->Pwd().c_str());
2445         size_t count = files.GetCount();
2446         for ( size_t n = 0; n < count; n++ )
2447         {
2448             wxPrintf(_T("\t%s\n"), files[n].c_str());
2449         }
2450         wxPuts(_T("End of the file list"));
2451     }
2452
2453     if ( !ftp->GetDirList(files) )
2454     {
2455         wxPuts(_T("ERROR: failed to get LIST of files"));
2456     }
2457     else
2458     {
2459         wxPrintf(_T("Detailed list of files under '%s':\n"), ftp->Pwd().c_str());
2460         size_t count = files.GetCount();
2461         for ( size_t n = 0; n < count; n++ )
2462         {
2463             wxPrintf(_T("\t%s\n"), files[n].c_str());
2464         }
2465         wxPuts(_T("End of the file list"));
2466     }
2467
2468     if ( !ftp->ChDir(_T("..")) )
2469     {
2470         wxPuts(_T("ERROR: failed to cd to .."));
2471     }
2472
2473     wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2474 }
2475
2476 static void TestFtpDownload()
2477 {
2478     wxPuts(_T("*** Testing wxFTP download ***\n"));
2479
2480     // test RETR
2481     wxInputStream *in = ftp->GetInputStream(filename);
2482     if ( !in )
2483     {
2484         wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
2485     }
2486     else
2487     {
2488         size_t size = in->GetSize();
2489         wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
2490         fflush(stdout);
2491
2492         wxChar *data = new wxChar[size];
2493         if ( !in->Read(data, size) )
2494         {
2495             wxPuts(_T("ERROR: read error"));
2496         }
2497         else
2498         {
2499             wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
2500         }
2501
2502         delete [] data;
2503         delete in;
2504     }
2505 }
2506
2507 static void TestFtpFileSize()
2508 {
2509     wxPuts(_T("*** Testing FTP SIZE command ***"));
2510
2511     if ( !ftp->ChDir(directory) )
2512     {
2513         wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
2514     }
2515
2516     wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2517
2518     if ( ftp->FileExists(filename) )
2519     {
2520         int size = ftp->GetFileSize(filename);
2521         if ( size == -1 )
2522             wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
2523         else
2524             wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
2525     }
2526     else
2527     {
2528         wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
2529     }
2530 }
2531
2532 static void TestFtpMisc()
2533 {
2534     wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
2535
2536     if ( ftp->SendCommand(_T("STAT")) != '2' )
2537     {
2538         wxPuts(_T("ERROR: STAT failed"));
2539     }
2540     else
2541     {
2542         wxPrintf(_T("STAT returned:\n\n%s\n"), ftp->GetLastResult().c_str());
2543     }
2544
2545     if ( ftp->SendCommand(_T("HELP SITE")) != '2' )
2546     {
2547         wxPuts(_T("ERROR: HELP SITE failed"));
2548     }
2549     else
2550     {
2551         wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
2552                ftp->GetLastResult().c_str());
2553     }
2554 }
2555
2556 #if TEST_INTERACTIVE
2557
2558 static void TestFtpInteractive()
2559 {
2560     wxPuts(_T("\n*** Interactive wxFTP test ***"));
2561
2562     wxChar buf[128];
2563
2564     for ( ;; )
2565     {
2566         wxPrintf(_T("Enter FTP command: "));
2567         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
2568             break;
2569
2570         // kill the last '\n'
2571         buf[wxStrlen(buf) - 1] = 0;
2572
2573         // special handling of LIST and NLST as they require data connection
2574         wxString start(buf, 4);
2575         start.MakeUpper();
2576         if ( start == _T("LIST") || start == _T("NLST") )
2577         {
2578             wxString wildcard;
2579             if ( wxStrlen(buf) > 4 )
2580                 wildcard = buf + 5;
2581
2582             wxArrayString files;
2583             if ( !ftp->GetList(files, wildcard, start == _T("LIST")) )
2584             {
2585                 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
2586             }
2587             else
2588             {
2589                 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
2590                        start.c_str(), wildcard.c_str(), ftp->Pwd().c_str());
2591                 size_t count = files.GetCount();
2592                 for ( size_t n = 0; n < count; n++ )
2593                 {
2594                     wxPrintf(_T("\t%s\n"), files[n].c_str());
2595                 }
2596                 wxPuts(_T("--- End of the file list"));
2597             }
2598         }
2599         else // !list
2600         {
2601             wxChar ch = ftp->SendCommand(buf);
2602             wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
2603             if ( ch )
2604             {
2605                 wxPrintf(_T(" (return code %c)"), ch);
2606             }
2607
2608             wxPrintf(_T(", server reply:\n%s\n\n"), ftp->GetLastResult().c_str());
2609         }
2610     }
2611
2612     wxPuts(_T("\n*** done ***"));
2613 }
2614
2615 #endif // TEST_INTERACTIVE
2616
2617 static void TestFtpUpload()
2618 {
2619     wxPuts(_T("*** Testing wxFTP uploading ***\n"));
2620
2621     // upload a file
2622     static const wxChar *file1 = _T("test1");
2623     static const wxChar *file2 = _T("test2");
2624     wxOutputStream *out = ftp->GetOutputStream(file1);
2625     if ( out )
2626     {
2627         wxPrintf(_T("--- Uploading to %s ---\n"), file1);
2628         out->Write("First hello", 11);
2629         delete out;
2630     }
2631
2632     // send a command to check the remote file
2633     if ( ftp->SendCommand(wxString(_T("STAT ")) + file1) != '2' )
2634     {
2635         wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
2636     }
2637     else
2638     {
2639         wxPrintf(_T("STAT %s returned:\n\n%s\n"),
2640                file1, ftp->GetLastResult().c_str());
2641     }
2642
2643     out = ftp->GetOutputStream(file2);
2644     if ( out )
2645     {
2646         wxPrintf(_T("--- Uploading to %s ---\n"), file1);
2647         out->Write("Second hello", 12);
2648         delete out;
2649     }
2650 }
2651
2652 #endif // TEST_FTP
2653
2654 // ----------------------------------------------------------------------------
2655 // stack backtrace
2656 // ----------------------------------------------------------------------------
2657
2658 #ifdef TEST_STACKWALKER
2659
2660 #if wxUSE_STACKWALKER
2661
2662 #include "wx/stackwalk.h"
2663
2664 class StackDump : public wxStackWalker
2665 {
2666 public:
2667     StackDump(const char *argv0)
2668         : wxStackWalker(argv0)
2669     {
2670     }
2671
2672     virtual void Walk(size_t skip = 1, size_t maxdepth = wxSTACKWALKER_MAX_DEPTH)
2673     {
2674         wxPuts(_T("Stack dump:"));
2675
2676         wxStackWalker::Walk(skip, maxdepth);
2677     }
2678
2679 protected:
2680     virtual void OnStackFrame(const wxStackFrame& frame)
2681     {
2682         printf("[%2d] ", (int) frame.GetLevel());
2683
2684         wxString name = frame.GetName();
2685         if ( !name.empty() )
2686         {
2687             printf("%-20.40s", (const char*)name.mb_str());
2688         }
2689         else
2690         {
2691             printf("0x%08lx", (unsigned long)frame.GetAddress());
2692         }
2693
2694         if ( frame.HasSourceLocation() )
2695         {
2696             printf("\t%s:%d",
2697                    (const char*)frame.GetFileName().mb_str(),
2698                    (int)frame.GetLine());
2699         }
2700
2701         puts("");
2702
2703         wxString type, val;
2704         for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
2705         {
2706             printf("\t%s %s = %s\n", (const char*)type.mb_str(),
2707                                      (const char*)name.mb_str(),
2708                                      (const char*)val.mb_str());
2709         }
2710     }
2711 };
2712
2713 static void TestStackWalk(const char *argv0)
2714 {
2715     wxPuts(_T("*** Testing wxStackWalker ***\n"));
2716
2717     StackDump dump(argv0);
2718     dump.Walk();
2719 }
2720
2721 #endif // wxUSE_STACKWALKER
2722
2723 #endif // TEST_STACKWALKER
2724
2725 // ----------------------------------------------------------------------------
2726 // standard paths
2727 // ----------------------------------------------------------------------------
2728
2729 #ifdef TEST_STDPATHS
2730
2731 #include "wx/stdpaths.h"
2732 #include "wx/wxchar.h"      // wxPrintf
2733
2734 static void TestStandardPaths()
2735 {
2736     wxPuts(_T("*** Testing wxStandardPaths ***\n"));
2737
2738     wxTheApp->SetAppName(_T("console"));
2739
2740     wxStandardPathsBase& stdp = wxStandardPaths::Get();
2741     wxPrintf(_T("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
2742     wxPrintf(_T("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
2743     wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
2744     wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
2745     wxPrintf(_T("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
2746     wxPrintf(_T("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
2747     wxPrintf(_T("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
2748     wxPrintf(_T("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
2749     wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
2750     wxPrintf(_T("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
2751     wxPrintf(_T("Localized res. dir:\t%s\n"),
2752              stdp.GetLocalizedResourcesDir(_T("fr")).c_str());
2753     wxPrintf(_T("Message catalogs dir:\t%s\n"),
2754              stdp.GetLocalizedResourcesDir
2755                   (
2756                     _T("fr"),
2757                     wxStandardPaths::ResourceCat_Messages
2758                   ).c_str());
2759 }
2760
2761 #endif // TEST_STDPATHS
2762
2763 // ----------------------------------------------------------------------------
2764 // streams
2765 // ----------------------------------------------------------------------------
2766
2767 #ifdef TEST_STREAMS
2768
2769 #include "wx/wfstream.h"
2770 #include "wx/mstream.h"
2771
2772 static void TestFileStream()
2773 {
2774     wxPuts(_T("*** Testing wxFileInputStream ***"));
2775
2776     static const wxString filename = _T("testdata.fs");
2777     {
2778         wxFileOutputStream fsOut(filename);
2779         fsOut.Write("foo", 3);
2780     }
2781
2782     {
2783         wxFileInputStream fsIn(filename);
2784         wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
2785         int c;
2786         while ( (c=fsIn.GetC()) != wxEOF  )
2787         {
2788             wxPutchar(c);
2789         }
2790     }
2791
2792     if ( !wxRemoveFile(filename) )
2793     {
2794         wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
2795     }
2796
2797     wxPuts(_T("\n*** wxFileInputStream test done ***"));
2798 }
2799
2800 static void TestMemoryStream()
2801 {
2802     wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
2803
2804     wxMemoryOutputStream memOutStream;
2805     wxPrintf(_T("Initially out stream offset: %lu\n"),
2806              (unsigned long)memOutStream.TellO());
2807
2808     for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
2809     {
2810         memOutStream.PutC(*p);
2811     }
2812
2813     wxPrintf(_T("Final out stream offset: %lu\n"),
2814              (unsigned long)memOutStream.TellO());
2815
2816     wxPuts(_T("*** Testing wxMemoryInputStream ***"));
2817
2818     wxChar buf[1024];
2819     size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
2820
2821     wxMemoryInputStream memInpStream(buf, len);
2822     wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
2823     int c;
2824     while ( (c=memInpStream.GetC()) != wxEOF )
2825     {
2826         wxPutchar(c);
2827     }
2828
2829     wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
2830 }
2831
2832 #endif // TEST_STREAMS
2833
2834 // ----------------------------------------------------------------------------
2835 // timers
2836 // ----------------------------------------------------------------------------
2837
2838 #ifdef TEST_TIMER
2839
2840 #include "wx/stopwatch.h"
2841 #include "wx/utils.h"
2842
2843 static void TestStopWatch()
2844 {
2845     wxPuts(_T("*** Testing wxStopWatch ***\n"));
2846
2847     wxStopWatch sw;
2848     sw.Pause();
2849     wxPrintf(_T("Initially paused, after 2 seconds time is..."));
2850     fflush(stdout);
2851     wxSleep(2);
2852     wxPrintf(_T("\t%ldms\n"), sw.Time());
2853
2854     wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
2855     fflush(stdout);
2856     sw.Resume();
2857     wxSleep(3);
2858     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2859
2860     sw.Pause();
2861     wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
2862     fflush(stdout);
2863     wxSleep(2);
2864     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2865
2866     sw.Resume();
2867     wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
2868     fflush(stdout);
2869     wxSleep(2);
2870     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2871
2872     wxStopWatch sw2;
2873     wxPuts(_T("\nChecking for 'backwards clock' bug..."));
2874     for ( size_t n = 0; n < 70; n++ )
2875     {
2876         sw2.Start();
2877
2878         for ( size_t m = 0; m < 100000; m++ )
2879         {
2880             if ( sw.Time() < 0 || sw2.Time() < 0 )
2881             {
2882                 wxPuts(_T("\ntime is negative - ERROR!"));
2883             }
2884         }
2885
2886         wxPutchar('.');
2887         fflush(stdout);
2888     }
2889
2890     wxPuts(_T(", ok."));
2891 }
2892
2893 #include "wx/timer.h"
2894 #include "wx/evtloop.h"
2895
2896 void TestTimer()
2897 {
2898     wxPuts(_T("*** Testing wxTimer ***\n"));
2899
2900     class MyTimer : public wxTimer
2901     {
2902     public:
2903         MyTimer() : wxTimer() { m_num = 0; }
2904
2905         virtual void Notify()
2906         {
2907             wxPrintf(_T("%d"), m_num++);
2908             fflush(stdout);
2909
2910             if ( m_num == 10 )
2911             {
2912                 wxPrintf(_T("... exiting the event loop"));
2913                 Stop();
2914
2915                 wxEventLoop::GetActive()->Exit(0);
2916                 wxPuts(_T(", ok."));
2917             }
2918
2919             fflush(stdout);
2920         }
2921
2922     private:
2923         int m_num;
2924     };
2925
2926     wxEventLoop loop;
2927
2928     wxTimer timer1;
2929     timer1.Start(100, true /* one shot */);
2930     timer1.Stop();
2931     timer1.Start(100, true /* one shot */);
2932
2933     MyTimer timer;
2934     timer.Start(500);
2935
2936     loop.Run();
2937 }
2938
2939 #endif // TEST_TIMER
2940
2941 // ----------------------------------------------------------------------------
2942 // wxVolume tests
2943 // ----------------------------------------------------------------------------
2944
2945 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
2946     #undef TEST_VOLUME
2947 #endif
2948
2949 #ifdef TEST_VOLUME
2950
2951 #include "wx/volume.h"
2952
2953 static const wxChar *volumeKinds[] =
2954 {
2955     _T("floppy"),
2956     _T("hard disk"),
2957     _T("CD-ROM"),
2958     _T("DVD-ROM"),
2959     _T("network volume"),
2960     _T("other volume"),
2961 };
2962
2963 static void TestFSVolume()
2964 {
2965     wxPuts(_T("*** Testing wxFSVolume class ***"));
2966
2967     wxArrayString volumes = wxFSVolume::GetVolumes();
2968     size_t count = volumes.GetCount();
2969
2970     if ( !count )
2971     {
2972         wxPuts(_T("ERROR: no mounted volumes?"));
2973         return;
2974     }
2975
2976     wxPrintf(_T("%u mounted volumes found:\n"), count);
2977
2978     for ( size_t n = 0; n < count; n++ )
2979     {
2980         wxFSVolume vol(volumes[n]);
2981         if ( !vol.IsOk() )
2982         {
2983             wxPuts(_T("ERROR: couldn't create volume"));
2984             continue;
2985         }
2986
2987         wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
2988                  n + 1,
2989                  vol.GetDisplayName().c_str(),
2990                  vol.GetName().c_str(),
2991                  volumeKinds[vol.GetKind()],
2992                  vol.IsWritable() ? _T("rw") : _T("ro"),
2993                  vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
2994                                                      : _T("fixed"));
2995     }
2996 }
2997
2998 #endif // TEST_VOLUME
2999
3000 // ----------------------------------------------------------------------------
3001 // wide char and Unicode support
3002 // ----------------------------------------------------------------------------
3003
3004 #ifdef TEST_WCHAR
3005
3006 #include "wx/strconv.h"
3007 #include "wx/fontenc.h"
3008 #include "wx/encconv.h"
3009 #include "wx/buffer.h"
3010
3011 static const unsigned char utf8koi8r[] =
3012 {
3013     208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3014     208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3015     176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3016     208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3017     181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3018     208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3019     178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3020 };
3021
3022 static const unsigned char utf8iso8859_1[] =
3023 {
3024     0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3025     0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3026     0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3027     0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3028     0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3029 };
3030
3031 static const unsigned char utf8Invalid[] =
3032 {
3033     0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3034     0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3035     0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3036     0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3037     0x6c, 0x61, 0x79, 0
3038 };
3039
3040 static const struct Utf8Data
3041 {
3042     const unsigned char *text;
3043     size_t len;
3044     const wxChar *charset;
3045     wxFontEncoding encoding;
3046 } utf8data[] =
3047 {
3048     { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3049     { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3050     { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3051 };
3052
3053 static void TestUtf8()
3054 {
3055     wxPuts(_T("*** Testing UTF8 support ***\n"));
3056
3057     char buf[1024];
3058     wchar_t wbuf[1024];
3059
3060     for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
3061     {
3062         const Utf8Data& u8d = utf8data[n];
3063         if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3064                               WXSIZEOF(wbuf)) == (size_t)-1 )
3065         {
3066             wxPuts(_T("ERROR: UTF-8 decoding failed."));
3067         }
3068         else
3069         {
3070             wxCSConv conv(u8d.charset);
3071             if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3072             {
3073                 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3074             }
3075             else
3076             {
3077                 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3078             }
3079         }
3080
3081         wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
3082         if ( s.empty() )
3083             s = _T("<< conversion failed >>");
3084         wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3085
3086     }
3087
3088     wxPuts(wxEmptyString);
3089 }
3090
3091 static void TestEncodingConverter()
3092 {
3093     wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3094
3095     // using wxEncodingConverter should give the same result as above
3096     char buf[1024];
3097     wchar_t wbuf[1024];
3098     if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
3099                           WXSIZEOF(utf8koi8r)) == (size_t)-1 )
3100     {
3101         wxPuts(_T("ERROR: UTF-8 decoding failed."));
3102     }
3103     else
3104     {
3105         wxEncodingConverter ec;
3106         ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3107         ec.Convert(wbuf, buf);
3108         wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
3109     }
3110
3111     wxPuts(wxEmptyString);
3112 }
3113
3114 #endif // TEST_WCHAR
3115
3116 // ----------------------------------------------------------------------------
3117 // ZIP stream
3118 // ----------------------------------------------------------------------------
3119
3120 #ifdef TEST_ZIP
3121
3122 #include "wx/filesys.h"
3123 #include "wx/fs_zip.h"
3124 #include "wx/zipstrm.h"
3125
3126 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3127
3128 static void TestZipStreamRead()
3129 {
3130     wxPuts(_T("*** Testing ZIP reading ***\n"));
3131
3132     static const wxString filename = _T("foo");
3133     wxFFileInputStream in(TESTFILE_ZIP);
3134     wxZipInputStream istr(in);
3135     wxZipEntry entry(filename);
3136     istr.OpenEntry(entry);
3137
3138     wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
3139
3140     wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
3141     int c;
3142     while ( (c=istr.GetC()) != wxEOF )
3143     {
3144         wxPutchar(c);
3145         fflush(stdout);
3146     }
3147
3148     wxPuts(_T("\n----- done ------"));
3149 }
3150
3151 static void DumpZipDirectory(wxFileSystem& fs,
3152                              const wxString& dir,
3153                              const wxString& indent)
3154 {
3155     wxString prefix = wxString::Format(_T("%s#zip:%s"),
3156                                          TESTFILE_ZIP, dir.c_str());
3157     wxString wildcard = prefix + _T("/*");
3158
3159     wxString dirname = fs.FindFirst(wildcard, wxDIR);
3160     while ( !dirname.empty() )
3161     {
3162         if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3163         {
3164             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3165
3166             break;
3167         }
3168
3169         wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3170
3171         DumpZipDirectory(fs, dirname,
3172                          indent + wxString(_T(' '), 4));
3173
3174         dirname = fs.FindNext();
3175     }
3176
3177     wxString filename = fs.FindFirst(wildcard, wxFILE);
3178     while ( !filename.empty() )
3179     {
3180         if ( !filename.StartsWith(prefix, &filename) )
3181         {
3182             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3183
3184             break;
3185         }
3186
3187         wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3188
3189         filename = fs.FindNext();
3190     }
3191 }
3192
3193 static void TestZipFileSystem()
3194 {
3195     wxPuts(_T("*** Testing ZIP file system ***\n"));
3196
3197     wxFileSystem::AddHandler(new wxZipFSHandler);
3198     wxFileSystem fs;
3199     wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3200
3201     DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3202 }
3203
3204 #endif // TEST_ZIP
3205
3206 // ----------------------------------------------------------------------------
3207 // date time
3208 // ----------------------------------------------------------------------------
3209
3210 #ifdef TEST_DATETIME
3211
3212 #include "wx/math.h"
3213 #include "wx/datetime.h"
3214
3215 // this test miscellaneous static wxDateTime functions
3216
3217 #if TEST_ALL
3218
3219 static void TestTimeStatic()
3220 {
3221     wxPuts(_T("\n*** wxDateTime static methods test ***"));
3222
3223     // some info about the current date
3224     int year = wxDateTime::GetCurrentYear();
3225     wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
3226            year,
3227            wxDateTime::IsLeapYear(year) ? "" : "not ",
3228            wxDateTime::GetNumberOfDays(year));
3229
3230     wxDateTime::Month month = wxDateTime::GetCurrentMonth();
3231     wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
3232            wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
3233            wxDateTime::GetMonthName(month).c_str(),
3234            wxDateTime::GetNumberOfDays(month));
3235 }
3236
3237 // test time zones stuff
3238 static void TestTimeZones()
3239 {
3240     wxPuts(_T("\n*** wxDateTime timezone test ***"));
3241
3242     wxDateTime now = wxDateTime::Now();
3243
3244     wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
3245     wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
3246     wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
3247     wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
3248     wxPrintf(_T("               Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
3249     wxPrintf(_T("             New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
3250
3251     wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3252
3253     wxDateTime::Tm tm = now.GetTm();
3254     if ( wxDateTime(tm) != now )
3255     {
3256         wxPrintf(_T("ERROR: got %s instead of %s\n"),
3257                  wxDateTime(tm).Format().c_str(), now.Format().c_str());
3258     }
3259 }
3260
3261 // test some minimal support for the dates outside the standard range
3262 static void TestTimeRange()
3263 {
3264     wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
3265
3266     static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
3267
3268     wxPrintf(_T("Unix epoch:\t%s\n"),
3269              wxDateTime(2440587.5).Format(fmt).c_str());
3270     wxPrintf(_T("Feb 29, 0: \t%s\n"),
3271              wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3272     wxPrintf(_T("JDN 0:     \t%s\n"),
3273              wxDateTime(0.0).Format(fmt).c_str());
3274     wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3275              wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3276     wxPrintf(_T("May 29, 2099:\t%s\n"),
3277              wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
3278 }
3279
3280 // test DST calculations
3281 static void TestTimeDST()
3282 {
3283     wxPuts(_T("\n*** wxDateTime DST test ***"));
3284
3285     wxPrintf(_T("DST is%s in effect now.\n\n"),
3286              wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
3287
3288     for ( int year = 1990; year < 2005; year++ )
3289     {
3290         wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3291                  year,
3292                  wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3293                  wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
3294     }
3295 }
3296
3297 #endif // TEST_ALL
3298
3299 #if TEST_INTERACTIVE
3300
3301 static void TestDateTimeInteractive()
3302 {
3303     wxPuts(_T("\n*** interactive wxDateTime tests ***"));
3304
3305     wxChar buf[128];
3306
3307     for ( ;; )
3308     {
3309         wxPrintf(_T("Enter a date: "));
3310         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
3311             break;
3312
3313         // kill the last '\n'
3314         buf[wxStrlen(buf) - 1] = 0;
3315
3316         wxDateTime dt;
3317         const wxChar *p = dt.ParseDate(buf);
3318         if ( !p )
3319         {
3320             wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
3321
3322             continue;
3323         }
3324         else if ( *p )
3325         {
3326             wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
3327         }
3328
3329         wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3330                  dt.Format(_T("%b %d, %Y")).c_str(),
3331                  dt.GetDayOfYear(),
3332                  dt.GetWeekOfMonth(wxDateTime::Monday_First),
3333                  dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3334                  dt.GetWeekOfYear(wxDateTime::Monday_First));
3335     }
3336
3337     wxPuts(_T("\n*** done ***"));
3338 }
3339
3340 #endif // TEST_INTERACTIVE
3341
3342 #if TEST_ALL
3343
3344 static void TestTimeMS()
3345 {
3346     wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
3347
3348     wxDateTime dt1 = wxDateTime::Now(),
3349                dt2 = wxDateTime::UNow();
3350
3351     wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
3352     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3353     wxPrintf(_T("Dummy loop: "));
3354     for ( int i = 0; i < 6000; i++ )
3355     {
3356         //for ( int j = 0; j < 10; j++ )
3357         {
3358             wxString s;
3359             s.Printf(_T("%g"), sqrt((float)i));
3360         }
3361
3362         if ( !(i % 100) )
3363             wxPutchar('.');
3364     }
3365     wxPuts(_T(", done"));
3366
3367     dt1 = dt2;
3368     dt2 = wxDateTime::UNow();
3369     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3370
3371     wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
3372
3373     wxPuts(_T("\n*** done ***"));
3374 }
3375
3376 static void TestTimeHolidays()
3377 {
3378     wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
3379
3380     wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3381     wxDateTime dtStart(1, tm.mon, tm.year),
3382                dtEnd = dtStart.GetLastMonthDay();
3383
3384     wxDateTimeArray hol;
3385     wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3386
3387     const wxChar *format = _T("%d-%b-%Y (%a)");
3388
3389     wxPrintf(_T("All holidays between %s and %s:\n"),
3390            dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3391
3392     size_t count = hol.GetCount();
3393     for ( size_t n = 0; n < count; n++ )
3394     {
3395         wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
3396     }
3397
3398     wxPuts(wxEmptyString);
3399 }
3400
3401 static void TestTimeZoneBug()
3402 {
3403     wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
3404
3405     wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3406     for ( int i = 0; i < 31; i++ )
3407     {
3408         wxPrintf(_T("Date %s: week day %s.\n"),
3409                date.Format(_T("%d-%m-%Y")).c_str(),
3410                date.GetWeekDayName(date.GetWeekDay()).c_str());
3411
3412         date += wxDateSpan::Day();
3413     }
3414
3415     wxPuts(wxEmptyString);
3416 }
3417
3418 static void TestTimeSpanFormat()
3419 {
3420     wxPuts(_T("\n*** wxTimeSpan tests ***"));
3421
3422     static const wxChar *formats[] =
3423     {
3424         _T("(default) %H:%M:%S"),
3425         _T("%E weeks and %D days"),
3426         _T("%l milliseconds"),
3427         _T("(with ms) %H:%M:%S:%l"),
3428         _T("100%% of minutes is %M"),       // test "%%"
3429         _T("%D days and %H hours"),
3430         _T("or also %S seconds"),
3431     };
3432
3433     wxTimeSpan ts1(1, 2, 3, 4),
3434                 ts2(111, 222, 333);
3435     for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3436     {
3437         wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
3438                ts1.Format(formats[n]).c_str(),
3439                ts2.Format(formats[n]).c_str());
3440     }
3441
3442     wxPuts(wxEmptyString);
3443 }
3444
3445 #endif // TEST_ALL
3446
3447 #endif // TEST_DATETIME
3448
3449 // ----------------------------------------------------------------------------
3450 // wxTextInput/OutputStream
3451 // ----------------------------------------------------------------------------
3452
3453 #ifdef TEST_TEXTSTREAM
3454
3455 #include "wx/txtstrm.h"
3456 #include "wx/wfstream.h"
3457
3458 static void TestTextInputStream()
3459 {
3460     wxPuts(_T("\n*** wxTextInputStream test ***"));
3461
3462     wxString filename = _T("testdata.fc");
3463     wxFileInputStream fsIn(filename);
3464     if ( !fsIn.Ok() )
3465     {
3466         wxPuts(_T("ERROR: couldn't open file."));
3467     }
3468     else
3469     {
3470         wxTextInputStream tis(fsIn);
3471
3472         size_t line = 1;
3473         for ( ;; )
3474         {
3475             const wxString s = tis.ReadLine();
3476
3477             // line could be non empty if the last line of the file isn't
3478             // terminated with EOL
3479             if ( fsIn.Eof() && s.empty() )
3480                 break;
3481
3482             wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
3483         }
3484     }
3485 }
3486
3487 #endif // TEST_TEXTSTREAM
3488
3489 // ----------------------------------------------------------------------------
3490 // threads
3491 // ----------------------------------------------------------------------------
3492
3493 #ifdef TEST_THREADS
3494
3495 #include "wx/thread.h"
3496
3497 static size_t gs_counter = (size_t)-1;
3498 static wxCriticalSection gs_critsect;
3499 static wxSemaphore gs_cond;
3500
3501 class MyJoinableThread : public wxThread
3502 {
3503 public:
3504     MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3505         { m_n = n; Create(); }
3506
3507     // thread execution starts here
3508     virtual ExitCode Entry();
3509
3510 private:
3511     size_t m_n;
3512 };
3513
3514 wxThread::ExitCode MyJoinableThread::Entry()
3515 {
3516     unsigned long res = 1;
3517     for ( size_t n = 1; n < m_n; n++ )
3518     {
3519         res *= n;
3520
3521         // it's a loooong calculation :-)
3522         Sleep(100);
3523     }
3524
3525     return (ExitCode)res;
3526 }
3527
3528 class MyDetachedThread : public wxThread
3529 {
3530 public:
3531     MyDetachedThread(size_t n, wxChar ch)
3532     {
3533         m_n = n;
3534         m_ch = ch;
3535         m_cancelled = false;
3536
3537         Create();
3538     }
3539
3540     // thread execution starts here
3541     virtual ExitCode Entry();
3542
3543     // and stops here
3544     virtual void OnExit();
3545
3546 private:
3547     size_t m_n; // number of characters to write
3548     wxChar m_ch;  // character to write
3549
3550     bool m_cancelled;   // false if we exit normally
3551 };
3552
3553 wxThread::ExitCode MyDetachedThread::Entry()
3554 {
3555     {
3556         wxCriticalSectionLocker lock(gs_critsect);
3557         if ( gs_counter == (size_t)-1 )
3558             gs_counter = 1;
3559         else
3560             gs_counter++;
3561     }
3562
3563     for ( size_t n = 0; n < m_n; n++ )
3564     {
3565         if ( TestDestroy() )
3566         {
3567             m_cancelled = true;
3568
3569             break;
3570         }
3571
3572         wxPutchar(m_ch);
3573         fflush(stdout);
3574
3575         wxThread::Sleep(100);
3576     }
3577
3578     return 0;
3579 }
3580
3581 void MyDetachedThread::OnExit()
3582 {
3583     wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
3584
3585     wxCriticalSectionLocker lock(gs_critsect);
3586     if ( !--gs_counter && !m_cancelled )
3587         gs_cond.Post();
3588 }
3589
3590 static void TestDetachedThreads()
3591 {
3592     wxPuts(_T("\n*** Testing detached threads ***"));
3593
3594     static const size_t nThreads = 3;
3595     MyDetachedThread *threads[nThreads];
3596     size_t n;
3597     for ( n = 0; n < nThreads; n++ )
3598     {
3599         threads[n] = new MyDetachedThread(10, 'A' + n);
3600     }
3601
3602     threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
3603     threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
3604
3605     for ( n = 0; n < nThreads; n++ )
3606     {
3607         threads[n]->Run();
3608     }
3609
3610     // wait until all threads terminate
3611     gs_cond.Wait();
3612
3613     wxPuts(wxEmptyString);
3614 }
3615
3616 static void TestJoinableThreads()
3617 {
3618     wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
3619
3620     // calc 10! in the background
3621     MyJoinableThread thread(10);
3622     thread.Run();
3623
3624     wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
3625              (unsigned long)thread.Wait());
3626 }
3627
3628 static void TestThreadSuspend()
3629 {
3630     wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
3631
3632     MyDetachedThread *thread = new MyDetachedThread(15, 'X');
3633
3634     thread->Run();
3635
3636     // this is for this demo only, in a real life program we'd use another
3637     // condition variable which would be signaled from wxThread::Entry() to
3638     // tell us that the thread really started running - but here just wait a
3639     // bit and hope that it will be enough (the problem is, of course, that
3640     // the thread might still not run when we call Pause() which will result
3641     // in an error)
3642     wxThread::Sleep(300);
3643
3644     for ( size_t n = 0; n < 3; n++ )
3645     {
3646         thread->Pause();
3647
3648         wxPuts(_T("\nThread suspended"));
3649         if ( n > 0 )
3650         {
3651             // don't sleep but resume immediately the first time
3652             wxThread::Sleep(300);
3653         }
3654         wxPuts(_T("Going to resume the thread"));
3655
3656         thread->Resume();
3657     }
3658
3659     wxPuts(_T("Waiting until it terminates now"));
3660
3661     // wait until the thread terminates
3662     gs_cond.Wait();
3663
3664     wxPuts(wxEmptyString);
3665 }
3666
3667 static void TestThreadDelete()
3668 {
3669     // As above, using Sleep() is only for testing here - we must use some
3670     // synchronisation object instead to ensure that the thread is still
3671     // running when we delete it - deleting a detached thread which already
3672     // terminated will lead to a crash!
3673
3674     wxPuts(_T("\n*** Testing thread delete function ***"));
3675
3676     MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
3677
3678     thread0->Delete();
3679
3680     wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
3681
3682     MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
3683
3684     thread1->Run();
3685
3686     wxThread::Sleep(300);
3687
3688     thread1->Delete();
3689
3690     wxPuts(_T("\nDeleted a running thread."));
3691
3692     MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
3693
3694     thread2->Run();
3695
3696     wxThread::Sleep(300);
3697
3698     thread2->Pause();
3699
3700     thread2->Delete();
3701
3702     wxPuts(_T("\nDeleted a sleeping thread."));
3703
3704     MyJoinableThread thread3(20);
3705     thread3.Run();
3706
3707     thread3.Delete();
3708
3709     wxPuts(_T("\nDeleted a joinable thread."));
3710
3711     MyJoinableThread thread4(2);
3712     thread4.Run();
3713
3714     wxThread::Sleep(300);
3715
3716     thread4.Delete();
3717
3718     wxPuts(_T("\nDeleted a joinable thread which already terminated."));
3719
3720     wxPuts(wxEmptyString);
3721 }
3722
3723 class MyWaitingThread : public wxThread
3724 {
3725 public:
3726     MyWaitingThread( wxMutex *mutex, wxCondition *condition )
3727     {
3728         m_mutex = mutex;
3729         m_condition = condition;
3730
3731         Create();
3732     }
3733
3734     virtual ExitCode Entry()
3735     {
3736         wxPrintf(_T("Thread %lu has started running.\n"), GetId());
3737         fflush(stdout);
3738
3739         gs_cond.Post();
3740
3741         wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
3742         fflush(stdout);
3743
3744         m_mutex->Lock();
3745         m_condition->Wait();
3746         m_mutex->Unlock();
3747
3748         wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
3749         fflush(stdout);
3750
3751         return 0;
3752     }
3753
3754 private:
3755     wxMutex *m_mutex;
3756     wxCondition *m_condition;
3757 };
3758
3759 static void TestThreadConditions()
3760 {
3761     wxMutex mutex;
3762     wxCondition condition(mutex);
3763
3764     // otherwise its difficult to understand which log messages pertain to
3765     // which condition
3766     //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
3767     //           condition.GetId(), gs_cond.GetId());
3768
3769     // create and launch threads
3770     MyWaitingThread *threads[10];
3771
3772     size_t n;
3773     for ( n = 0; n < WXSIZEOF(threads); n++ )
3774     {
3775         threads[n] = new MyWaitingThread( &mutex, &condition );
3776     }
3777
3778     for ( n = 0; n < WXSIZEOF(threads); n++ )
3779     {
3780         threads[n]->Run();
3781     }
3782
3783     // wait until all threads run
3784     wxPuts(_T("Main thread is waiting for the other threads to start"));
3785     fflush(stdout);
3786
3787     size_t nRunning = 0;
3788     while ( nRunning < WXSIZEOF(threads) )
3789     {
3790         gs_cond.Wait();
3791
3792         nRunning++;
3793
3794         wxPrintf(_T("Main thread: %u already running\n"), nRunning);
3795         fflush(stdout);
3796     }
3797
3798     wxPuts(_T("Main thread: all threads started up."));
3799     fflush(stdout);
3800
3801     wxThread::Sleep(500);
3802
3803 #if 1
3804     // now wake one of them up
3805     wxPrintf(_T("Main thread: about to signal the condition.\n"));
3806     fflush(stdout);
3807     condition.Signal();
3808 #endif
3809
3810     wxThread::Sleep(200);
3811
3812     // wake all the (remaining) threads up, so that they can exit
3813     wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
3814     fflush(stdout);
3815     condition.Broadcast();
3816
3817     // give them time to terminate (dirty!)
3818     wxThread::Sleep(500);
3819 }
3820
3821 // semaphore tests
3822 #include "wx/datetime.h"
3823
3824 class MySemaphoreThread : public wxThread
3825 {
3826 public:
3827     MySemaphoreThread(int i, wxSemaphore *sem)
3828         : wxThread(wxTHREAD_JOINABLE),
3829           m_sem(sem),
3830           m_i(i)
3831     {
3832         Create();
3833     }
3834
3835     virtual ExitCode Entry()
3836     {
3837         wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
3838                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
3839
3840         m_sem->Wait();
3841
3842         wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
3843                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
3844
3845         Sleep(1000);
3846
3847         wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
3848                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
3849
3850         m_sem->Post();
3851
3852         return 0;
3853     }
3854
3855 private:
3856     wxSemaphore *m_sem;
3857     int m_i;
3858 };
3859
3860 WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
3861
3862 static void TestSemaphore()
3863 {
3864     wxPuts(_T("*** Testing wxSemaphore class. ***"));
3865
3866     static const int SEM_LIMIT = 3;
3867
3868     wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
3869     ArrayThreads threads;
3870
3871     for ( int i = 0; i < 3*SEM_LIMIT; i++ )
3872     {
3873         threads.Add(new MySemaphoreThread(i, &sem));
3874         threads.Last()->Run();
3875     }
3876
3877     for ( size_t n = 0; n < threads.GetCount(); n++ )
3878     {
3879         threads[n]->Wait();
3880         delete threads[n];
3881     }
3882 }
3883
3884 #endif // TEST_THREADS
3885
3886 // ----------------------------------------------------------------------------
3887 // entry point
3888 // ----------------------------------------------------------------------------
3889
3890 #ifdef TEST_SNGLINST
3891     #include "wx/snglinst.h"
3892 #endif // TEST_SNGLINST
3893
3894 int main(int argc, char **argv)
3895 {
3896 #if wxUSE_UNICODE
3897     wxChar **wxArgv = new wxChar *[argc + 1];
3898
3899     {
3900         int n;
3901
3902         for (n = 0; n < argc; n++ )
3903         {
3904             wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
3905             wxArgv[n] = wxStrdup(warg);
3906         }
3907
3908         wxArgv[n] = NULL;
3909     }
3910 #else // !wxUSE_UNICODE
3911     #define wxArgv argv
3912 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
3913
3914     wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
3915
3916     wxInitializer initializer;
3917     if ( !initializer )
3918     {
3919         fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
3920
3921         return -1;
3922     }
3923
3924 #ifdef TEST_SNGLINST
3925     wxSingleInstanceChecker checker;
3926     if ( checker.Create(_T(".wxconsole.lock")) )
3927     {
3928         if ( checker.IsAnotherRunning() )
3929         {
3930             wxPrintf(_T("Another instance of the program is running, exiting.\n"));
3931
3932             return 1;
3933         }
3934
3935         // wait some time to give time to launch another instance
3936         wxPrintf(_T("Press \"Enter\" to continue..."));
3937         wxFgetc(stdin);
3938     }
3939     else // failed to create
3940     {
3941         wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
3942     }
3943 #endif // TEST_SNGLINST
3944
3945 #ifdef TEST_CMDLINE
3946     TestCmdLineConvert();
3947
3948 #if wxUSE_CMDLINE_PARSER
3949     static const wxCmdLineEntryDesc cmdLineDesc[] =
3950     {
3951         { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
3952             wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
3953         { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
3954         { wxCMD_LINE_SWITCH, "q", "quiet",   "be quiet" },
3955
3956         { wxCMD_LINE_OPTION, "o", "output",  "output file" },
3957         { wxCMD_LINE_OPTION, "i", "input",   "input dir" },
3958         { wxCMD_LINE_OPTION, "s", "size",    "output block size",
3959             wxCMD_LINE_VAL_NUMBER },
3960         { wxCMD_LINE_OPTION, "d", "date",    "output file date",
3961             wxCMD_LINE_VAL_DATE },
3962         { wxCMD_LINE_OPTION, "f", "double",  "output double",
3963             wxCMD_LINE_VAL_DOUBLE },
3964
3965         { wxCMD_LINE_PARAM,  NULL, NULL, "input file",
3966             wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
3967
3968         { wxCMD_LINE_NONE }
3969     };
3970
3971     wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
3972
3973     parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
3974                      wxCMD_LINE_VAL_STRING,
3975                      wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
3976
3977     switch ( parser.Parse() )
3978     {
3979         case -1:
3980             wxLogMessage(_T("Help was given, terminating."));
3981             break;
3982
3983         case 0:
3984             ShowCmdLine(parser);
3985             break;
3986
3987         default:
3988             wxLogMessage(_T("Syntax error detected, aborting."));
3989             break;
3990     }
3991 #endif // wxUSE_CMDLINE_PARSER
3992
3993 #endif // TEST_CMDLINE
3994
3995 #ifdef TEST_DIR
3996     #if TEST_ALL
3997         TestDirExists();
3998         TestDirEnum();
3999     #endif
4000     TestDirTraverse();
4001 #endif // TEST_DIR
4002
4003 #ifdef TEST_DYNLIB
4004     TestDllLoad();
4005     TestDllListLoaded();
4006 #endif // TEST_DYNLIB
4007
4008 #ifdef TEST_ENVIRON
4009     TestEnvironment();
4010 #endif // TEST_ENVIRON
4011
4012 #ifdef TEST_FILECONF
4013     TestFileConfRead();
4014 #endif // TEST_FILECONF
4015
4016 #ifdef TEST_LOCALE
4017     TestDefaultLang();
4018 #endif // TEST_LOCALE
4019
4020 #ifdef TEST_LOG
4021     wxPuts(_T("*** Testing wxLog ***"));
4022
4023     wxString s;
4024     for ( size_t n = 0; n < 8000; n++ )
4025     {
4026         s << (wxChar)(_T('A') + (n % 26));
4027     }
4028
4029     wxLogWarning(_T("The length of the string is %lu"),
4030                  (unsigned long)s.length());
4031
4032     wxString msg;
4033     msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
4034
4035     // this one shouldn't be truncated
4036     wxPrintf(msg);
4037
4038     // but this one will because log functions use fixed size buffer
4039     // (note that it doesn't need '\n' at the end neither - will be added
4040     //  by wxLog anyhow)
4041     wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
4042 #endif // TEST_LOG
4043
4044 #ifdef TEST_FILE
4045     TestFileRead();
4046     TestTextFileRead();
4047     TestFileCopy();
4048     TestTempFile();
4049 #endif // TEST_FILE
4050
4051 #ifdef TEST_FILENAME
4052     TestFileNameTemp();
4053     TestFileNameCwd();
4054     TestFileNameDirManip();
4055     TestFileNameComparison();
4056     TestFileNameOperations();
4057 #endif // TEST_FILENAME
4058
4059 #ifdef TEST_FILETIME
4060     TestFileGetTimes();
4061     #if 0
4062     TestFileSetTimes();
4063     #endif
4064 #endif // TEST_FILETIME
4065
4066 #ifdef TEST_FTP
4067     wxLog::AddTraceMask(FTP_TRACE_MASK);
4068
4069     // wxFTP cannot be a static variable as its ctor needs to access
4070     // wxWidgets internals after it has been initialized
4071     ftp = new wxFTP;
4072     ftp->SetLog(new wxProtocolLog(FTP_TRACE_MASK));
4073
4074     if ( TestFtpConnect() )
4075     {
4076         #if TEST_ALL
4077             TestFtpList();
4078             TestFtpDownload();
4079             TestFtpMisc();
4080             TestFtpFileSize();
4081             TestFtpUpload();
4082         #endif // TEST_ALL
4083
4084         #if TEST_INTERACTIVE
4085             //TestFtpInteractive();
4086         #endif
4087     }
4088     //else: connecting to the FTP server failed
4089
4090     delete ftp;
4091 #endif // TEST_FTP
4092
4093 #ifdef TEST_MIME
4094     //wxLog::AddTraceMask(_T("mime"));
4095     TestMimeEnum();
4096 #if 0
4097     TestMimeOverride();
4098     TestMimeAssociate();
4099 #endif
4100     TestMimeFilename();
4101 #endif // TEST_MIME
4102
4103 #ifdef TEST_INFO_FUNCTIONS
4104     TestOsInfo();
4105     TestPlatformInfo();
4106     TestUserInfo();
4107
4108     #if TEST_INTERACTIVE
4109         TestDiskInfo();
4110     #endif
4111 #endif // TEST_INFO_FUNCTIONS
4112
4113 #ifdef TEST_PATHLIST
4114     TestPathList();
4115 #endif // TEST_PATHLIST
4116
4117 #ifdef TEST_PRINTF
4118     TestPrintf();
4119 #endif // TEST_PRINTF
4120
4121 #ifdef TEST_REGCONF
4122     #if 0
4123     TestRegConfWrite();
4124     #endif
4125     TestRegConfRead();
4126 #endif // TEST_REGCONF
4127
4128 #if defined TEST_REGEX && TEST_INTERACTIVE
4129     TestRegExInteractive();
4130 #endif // defined TEST_REGEX && TEST_INTERACTIVE
4131
4132 #ifdef TEST_REGISTRY
4133     TestRegistryRead();
4134     TestRegistryAssociation();
4135 #endif // TEST_REGISTRY
4136
4137 #ifdef TEST_SOCKETS
4138     TestSocketServer();
4139     TestSocketClient();
4140 #endif // TEST_SOCKETS
4141
4142 #ifdef TEST_STREAMS
4143     #if TEST_ALL
4144         TestFileStream();
4145     #endif
4146         TestMemoryStream();
4147 #endif // TEST_STREAMS
4148
4149 #ifdef TEST_TEXTSTREAM
4150     TestTextInputStream();
4151 #endif // TEST_TEXTSTREAM
4152
4153 #ifdef TEST_THREADS
4154     int nCPUs = wxThread::GetCPUCount();
4155     wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
4156     if ( nCPUs != -1 )
4157         wxThread::SetConcurrency(nCPUs);
4158
4159         TestJoinableThreads();
4160
4161     #if TEST_ALL
4162         TestJoinableThreads();
4163         TestDetachedThreads();
4164         TestThreadSuspend();
4165         TestThreadDelete();
4166         TestThreadConditions();
4167         TestSemaphore();
4168     #endif
4169 #endif // TEST_THREADS
4170
4171 #ifdef TEST_TIMER
4172     TestStopWatch();
4173     TestTimer();
4174 #endif // TEST_TIMER
4175
4176 #ifdef TEST_DATETIME
4177     #if TEST_ALL
4178         TestTimeStatic();
4179         TestTimeRange();
4180         TestTimeZones();
4181         TestTimeDST();
4182         TestTimeHolidays();
4183         TestTimeSpanFormat();
4184         TestTimeMS();
4185
4186         TestTimeZoneBug();
4187     #endif
4188
4189     #if TEST_INTERACTIVE
4190         TestDateTimeInteractive();
4191     #endif
4192 #endif // TEST_DATETIME
4193
4194 #ifdef TEST_SCOPEGUARD
4195     TestScopeGuard();
4196 #endif
4197
4198 #ifdef TEST_STACKWALKER
4199 #if wxUSE_STACKWALKER
4200     TestStackWalk(argv[0]);
4201 #endif
4202 #endif // TEST_STACKWALKER
4203
4204 #ifdef TEST_STDPATHS
4205     TestStandardPaths();
4206 #endif
4207
4208 #ifdef TEST_USLEEP
4209     wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
4210     wxUsleep(3000);
4211 #endif // TEST_USLEEP
4212
4213 #ifdef TEST_VOLUME
4214     TestFSVolume();
4215 #endif // TEST_VOLUME
4216
4217 #ifdef TEST_WCHAR
4218     TestUtf8();
4219     TestEncodingConverter();
4220 #endif // TEST_WCHAR
4221
4222 #ifdef TEST_ZIP
4223     TestZipStreamRead();
4224     TestZipFileSystem();
4225 #endif // TEST_ZIP
4226
4227 #if wxUSE_UNICODE
4228     {
4229         for ( int n = 0; n < argc; n++ )
4230             free(wxArgv[n]);
4231
4232         delete [] wxArgv;
4233     }
4234 #endif // wxUSE_UNICODE
4235
4236     wxUnusedVar(argc);
4237     wxUnusedVar(argv);
4238     return 0;
4239 }