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