samples/console/console.cpp

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