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 #include "wx/stackwalk.h"
2640
2641 class StackDump : public wxStackWalker
2642 {
2643 public:
2644     StackDump(const char *argv0)
2645         : wxStackWalker(argv0)
2646     {
2647     }
2648
2649     virtual void Walk()
2650     {
2651         wxPuts(_T("Stack dump:"));
2652
2653         wxStackWalker::Walk();
2654     }
2655
2656 protected:
2657     virtual void OnStackFrame(const wxStackFrame& frame)
2658     {
2659         printf("[%2d] ", frame.GetLevel());
2660
2661         wxString name = frame.GetName();
2662         if ( !name.empty() )
2663         {
2664             printf("%-20.40s", name.mb_str());
2665         }
2666         else
2667         {
2668             printf("0x%08lx", (unsigned long)frame.GetAddress());
2669         }
2670
2671         if ( frame.HasSourceLocation() )
2672         {
2673             printf("\t%s:%d",
2674                    frame.GetFileName().mb_str(),
2675                    frame.GetLine());
2676         }
2677
2678         puts("");
2679
2680         wxString type, val;
2681         for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
2682         {
2683             printf("\t%s %s = %s\n", type.mb_str(), name.mb_str(), val.mb_str());
2684         }
2685     }
2686 };
2687
2688 static void TestStackWalk(const char *argv0)
2689 {
2690     wxPuts(_T("*** Testing wxStackWalker ***\n"));
2691
2692     StackDump dump(argv0);
2693     dump.Walk();
2694 }
2695
2696 #endif // TEST_STACKWALKER
2697
2698 // ----------------------------------------------------------------------------
2699 // standard paths
2700 // ----------------------------------------------------------------------------
2701
2702 #ifdef TEST_STDPATHS
2703
2704 #include "wx/stdpaths.h"
2705
2706 static void TestStandardPaths()
2707 {
2708     wxPuts(_T("*** Testing wxStandardPaths ***\n"));
2709
2710     wxTheApp->SetAppName(_T("console"));
2711
2712     wxStandardPaths& stdp = wxStandardPaths::Get();
2713     wxPrintf(_T("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
2714     wxPrintf(_T("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
2715     wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
2716     wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
2717     wxPrintf(_T("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
2718     wxPrintf(_T("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
2719     wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
2720 }
2721
2722 #endif // TEST_STDPATHS
2723
2724 // ----------------------------------------------------------------------------
2725 // streams
2726 // ----------------------------------------------------------------------------
2727
2728 #ifdef TEST_STREAMS
2729
2730 #include "wx/wfstream.h"
2731 #include "wx/mstream.h"
2732
2733 static void TestFileStream()
2734 {
2735     wxPuts(_T("*** Testing wxFileInputStream ***"));
2736
2737     static const wxString filename = _T("testdata.fs");
2738     {
2739         wxFileOutputStream fsOut(filename);
2740         fsOut.Write("foo", 3);
2741     }
2742
2743     wxFileInputStream fsIn(filename);
2744     wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
2745     while ( !fsIn.Eof() )
2746     {
2747         wxPutchar(fsIn.GetC());
2748     }
2749
2750     if ( !wxRemoveFile(filename) )
2751     {
2752         wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
2753     }
2754
2755     wxPuts(_T("\n*** wxFileInputStream test done ***"));
2756 }
2757
2758 static void TestMemoryStream()
2759 {
2760     wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
2761
2762     wxMemoryOutputStream memOutStream;
2763     wxPrintf(_T("Initially out stream offset: %lu\n"),
2764              (unsigned long)memOutStream.TellO());
2765
2766     for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
2767     {
2768         memOutStream.PutC(*p);
2769     }
2770
2771     wxPrintf(_T("Final out stream offset: %lu\n"),
2772              (unsigned long)memOutStream.TellO());
2773
2774     wxPuts(_T("*** Testing wxMemoryInputStream ***"));
2775
2776     wxChar buf[1024];
2777     size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
2778
2779     wxMemoryInputStream memInpStream(buf, len);
2780     wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
2781     while ( !memInpStream.Eof() )
2782     {
2783         wxPutchar(memInpStream.GetC());
2784     }
2785
2786     wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
2787 }
2788
2789 #endif // TEST_STREAMS
2790
2791 // ----------------------------------------------------------------------------
2792 // timers
2793 // ----------------------------------------------------------------------------
2794
2795 #ifdef TEST_TIMER
2796
2797 #include "wx/timer.h"
2798 #include "wx/utils.h"
2799
2800 static void TestStopWatch()
2801 {
2802     wxPuts(_T("*** Testing wxStopWatch ***\n"));
2803
2804     wxStopWatch sw;
2805     sw.Pause();
2806     wxPrintf(_T("Initially paused, after 2 seconds time is..."));
2807     fflush(stdout);
2808     wxSleep(2);
2809     wxPrintf(_T("\t%ldms\n"), sw.Time());
2810
2811     wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
2812     fflush(stdout);
2813     sw.Resume();
2814     wxSleep(3);
2815     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2816
2817     sw.Pause();
2818     wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
2819     fflush(stdout);
2820     wxSleep(2);
2821     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2822
2823     sw.Resume();
2824     wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
2825     fflush(stdout);
2826     wxSleep(2);
2827     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2828
2829     wxStopWatch sw2;
2830     wxPuts(_T("\nChecking for 'backwards clock' bug..."));
2831     for ( size_t n = 0; n < 70; n++ )
2832     {
2833         sw2.Start();
2834
2835         for ( size_t m = 0; m < 100000; m++ )
2836         {
2837             if ( sw.Time() < 0 || sw2.Time() < 0 )
2838             {
2839                 wxPuts(_T("\ntime is negative - ERROR!"));
2840             }
2841         }
2842
2843         wxPutchar('.');
2844         fflush(stdout);
2845     }
2846
2847     wxPuts(_T(", ok."));
2848 }
2849
2850 #endif // TEST_TIMER
2851
2852 // ----------------------------------------------------------------------------
2853 // vCard support
2854 // ----------------------------------------------------------------------------
2855
2856 #ifdef TEST_VCARD
2857
2858 #include "wx/vcard.h"
2859
2860 static void DumpVObject(size_t level, const wxVCardObject& vcard)
2861 {
2862     void *cookie;
2863     wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
2864     while ( vcObj )
2865     {
2866         wxPrintf(_T("%s%s"),
2867                wxString(_T('\t'), level).c_str(),
2868                vcObj->GetName().c_str());
2869
2870         wxString value;
2871         switch ( vcObj->GetType() )
2872         {
2873             case wxVCardObject::String:
2874             case wxVCardObject::UString:
2875                 {
2876                     wxString val;
2877                     vcObj->GetValue(&val);
2878                     value << _T('"') << val << _T('"');
2879                 }
2880                 break;
2881
2882             case wxVCardObject::Int:
2883                 {
2884                     unsigned int i;
2885                     vcObj->GetValue(&i);
2886                     value.Printf(_T("%u"), i);
2887                 }
2888                 break;
2889
2890             case wxVCardObject::Long:
2891                 {
2892                     unsigned long l;
2893                     vcObj->GetValue(&l);
2894                     value.Printf(_T("%lu"), l);
2895                 }
2896                 break;
2897
2898             case wxVCardObject::None:
2899                 break;
2900
2901             case wxVCardObject::Object:
2902                 value = _T("<node>");
2903                 break;
2904
2905             default:
2906                 value = _T("<unknown value type>");
2907         }
2908
2909         if ( !!value )
2910             wxPrintf(_T(" = %s"), value.c_str());
2911         wxPutchar('\n');
2912
2913         DumpVObject(level + 1, *vcObj);
2914
2915         delete vcObj;
2916         vcObj = vcard.GetNextProp(&cookie);
2917     }
2918 }
2919
2920 static void DumpVCardAddresses(const wxVCard& vcard)
2921 {
2922     wxPuts(_T("\nShowing all addresses from vCard:\n"));
2923
2924     size_t nAdr = 0;
2925     void *cookie;
2926     wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
2927     while ( addr )
2928     {
2929         wxString flagsStr;
2930         int flags = addr->GetFlags();
2931         if ( flags & wxVCardAddress::Domestic )
2932         {
2933             flagsStr << _T("domestic ");
2934         }
2935         if ( flags & wxVCardAddress::Intl )
2936         {
2937             flagsStr << _T("international ");
2938         }
2939         if ( flags & wxVCardAddress::Postal )
2940         {
2941             flagsStr << _T("postal ");
2942         }
2943         if ( flags & wxVCardAddress::Parcel )
2944         {
2945             flagsStr << _T("parcel ");
2946         }
2947         if ( flags & wxVCardAddress::Home )
2948         {
2949             flagsStr << _T("home ");
2950         }
2951         if ( flags & wxVCardAddress::Work )
2952         {
2953             flagsStr << _T("work ");
2954         }
2955
2956         wxPrintf(_T("Address %u:\n")
2957                "\tflags = %s\n"
2958                "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
2959                ++nAdr,
2960                flagsStr.c_str(),
2961                addr->GetPostOffice().c_str(),
2962                addr->GetExtAddress().c_str(),
2963                addr->GetStreet().c_str(),
2964                addr->GetLocality().c_str(),
2965                addr->GetRegion().c_str(),
2966                addr->GetPostalCode().c_str(),
2967                addr->GetCountry().c_str()
2968                );
2969
2970         delete addr;
2971         addr = vcard.GetNextAddress(&cookie);
2972     }
2973 }
2974
2975 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
2976 {
2977     wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
2978
2979     size_t nPhone = 0;
2980     void *cookie;
2981     wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
2982     while ( phone )
2983     {
2984         wxString flagsStr;
2985         int flags = phone->GetFlags();
2986         if ( flags & wxVCardPhoneNumber::Voice )
2987         {
2988             flagsStr << _T("voice ");
2989         }
2990         if ( flags & wxVCardPhoneNumber::Fax )
2991         {
2992             flagsStr << _T("fax ");
2993         }
2994         if ( flags & wxVCardPhoneNumber::Cellular )
2995         {
2996             flagsStr << _T("cellular ");
2997         }
2998         if ( flags & wxVCardPhoneNumber::Modem )
2999         {
3000             flagsStr << _T("modem ");
3001         }
3002         if ( flags & wxVCardPhoneNumber::Home )
3003         {
3004             flagsStr << _T("home ");
3005         }
3006         if ( flags & wxVCardPhoneNumber::Work )
3007         {
3008             flagsStr << _T("work ");
3009         }
3010
3011         wxPrintf(_T("Phone number %u:\n")
3012                "\tflags = %s\n"
3013                "\tvalue = %s\n",
3014                ++nPhone,
3015                flagsStr.c_str(),
3016                phone->GetNumber().c_str()
3017                );
3018
3019         delete phone;
3020         phone = vcard.GetNextPhoneNumber(&cookie);
3021     }
3022 }
3023
3024 static void TestVCardRead()
3025 {
3026     wxPuts(_T("*** Testing wxVCard reading ***\n"));
3027
3028     wxVCard vcard(_T("vcard.vcf"));
3029     if ( !vcard.IsOk() )
3030     {
3031         wxPuts(_T("ERROR: couldn't load vCard."));
3032     }
3033     else
3034     {
3035         // read individual vCard properties
3036         wxVCardObject *vcObj = vcard.GetProperty("FN");
3037         wxString value;
3038         if ( vcObj )
3039         {
3040             vcObj->GetValue(&value);
3041             delete vcObj;
3042         }
3043         else
3044         {
3045             value = _T("<none>");
3046         }
3047
3048         wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
3049
3050
3051         if ( !vcard.GetFullName(&value) )
3052         {
3053             value = _T("<none>");
3054         }
3055
3056         wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
3057
3058         // now show how to deal with multiply occuring properties
3059         DumpVCardAddresses(vcard);
3060         DumpVCardPhoneNumbers(vcard);
3061
3062         // and finally show all
3063         wxPuts(_T("\nNow dumping the entire vCard:\n")
3064              "-----------------------------\n");
3065
3066         DumpVObject(0, vcard);
3067     }
3068 }
3069
3070 static void TestVCardWrite()
3071 {
3072     wxPuts(_T("*** Testing wxVCard writing ***\n"));
3073
3074     wxVCard vcard;
3075     if ( !vcard.IsOk() )
3076     {
3077         wxPuts(_T("ERROR: couldn't create vCard."));
3078     }
3079     else
3080     {
3081         // set some fields
3082         vcard.SetName("Zeitlin", "Vadim");
3083         vcard.SetFullName("Vadim Zeitlin");
3084         vcard.SetOrganization("wxWidgets", "R&D");
3085
3086         // just dump the vCard back
3087         wxPuts(_T("Entire vCard follows:\n"));
3088         wxPuts(vcard.Write());
3089     }
3090 }
3091
3092 #endif // TEST_VCARD
3093
3094 // ----------------------------------------------------------------------------
3095 // wxVolume tests
3096 // ----------------------------------------------------------------------------
3097
3098 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
3099     #undef TEST_VOLUME
3100 #endif
3101
3102 #ifdef TEST_VOLUME
3103
3104 #include "wx/volume.h"
3105
3106 static const wxChar *volumeKinds[] =
3107 {
3108     _T("floppy"),
3109     _T("hard disk"),
3110     _T("CD-ROM"),
3111     _T("DVD-ROM"),
3112     _T("network volume"),
3113     _T("other volume"),
3114 };
3115
3116 static void TestFSVolume()
3117 {
3118     wxPuts(_T("*** Testing wxFSVolume class ***"));
3119
3120     wxArrayString volumes = wxFSVolume::GetVolumes();
3121     size_t count = volumes.GetCount();
3122
3123     if ( !count )
3124     {
3125         wxPuts(_T("ERROR: no mounted volumes?"));
3126         return;
3127     }
3128
3129     wxPrintf(_T("%u mounted volumes found:\n"), count);
3130
3131     for ( size_t n = 0; n < count; n++ )
3132     {
3133         wxFSVolume vol(volumes[n]);
3134         if ( !vol.IsOk() )
3135         {
3136             wxPuts(_T("ERROR: couldn't create volume"));
3137             continue;
3138         }
3139
3140         wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3141                  n + 1,
3142                  vol.GetDisplayName().c_str(),
3143                  vol.GetName().c_str(),
3144                  volumeKinds[vol.GetKind()],
3145                  vol.IsWritable() ? _T("rw") : _T("ro"),
3146                  vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3147                                                      : _T("fixed"));
3148     }
3149 }
3150
3151 #endif // TEST_VOLUME
3152
3153 // ----------------------------------------------------------------------------
3154 // wide char and Unicode support
3155 // ----------------------------------------------------------------------------
3156
3157 #ifdef TEST_WCHAR
3158
3159 #include "wx/strconv.h"
3160 #include "wx/fontenc.h"
3161 #include "wx/encconv.h"
3162 #include "wx/buffer.h"
3163
3164 static const unsigned char utf8koi8r[] =
3165 {
3166     208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3167     208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3168     176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3169     208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3170     181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3171     208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3172     178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3173 };
3174
3175 static const unsigned char utf8iso8859_1[] =
3176 {
3177     0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3178     0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3179     0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3180     0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3181     0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3182 };
3183
3184 static const unsigned char utf8Invalid[] =
3185 {
3186     0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3187     0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3188     0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3189     0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3190     0x6c, 0x61, 0x79, 0
3191 };
3192
3193 static const struct Utf8Data
3194 {
3195     const unsigned char *text;
3196     size_t len;
3197     const wxChar *charset;
3198     wxFontEncoding encoding;
3199 } utf8data[] =
3200 {
3201     { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3202     { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3203     { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3204 };
3205
3206 static void TestUtf8()
3207 {
3208     wxPuts(_T("*** Testing UTF8 support ***\n"));
3209
3210     char buf[1024];
3211     wchar_t wbuf[1024];
3212
3213     for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
3214     {
3215         const Utf8Data& u8d = utf8data[n];
3216         if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3217                               WXSIZEOF(wbuf)) == (size_t)-1 )
3218         {
3219             wxPuts(_T("ERROR: UTF-8 decoding failed."));
3220         }
3221         else
3222         {
3223             wxCSConv conv(u8d.charset);
3224             if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3225             {
3226                 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3227             }
3228             else
3229             {
3230                 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3231             }
3232         }
3233
3234         wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
3235         if ( s.empty() )
3236             s = _T("<< conversion failed >>");
3237         wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3238
3239     }
3240
3241     wxPuts(wxEmptyString);
3242 }
3243
3244 static void TestEncodingConverter()
3245 {
3246     wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3247
3248     // using wxEncodingConverter should give the same result as above
3249     char buf[1024];
3250     wchar_t wbuf[1024];
3251     if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
3252                           WXSIZEOF(utf8koi8r)) == (size_t)-1 )
3253     {
3254         wxPuts(_T("ERROR: UTF-8 decoding failed."));
3255     }
3256     else
3257     {
3258         wxEncodingConverter ec;
3259         ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3260         ec.Convert(wbuf, buf);
3261         wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
3262     }
3263
3264     wxPuts(wxEmptyString);
3265 }
3266
3267 #endif // TEST_WCHAR
3268
3269 // ----------------------------------------------------------------------------
3270 // ZIP stream
3271 // ----------------------------------------------------------------------------
3272
3273 #ifdef TEST_ZIP
3274
3275 #include "wx/filesys.h"
3276 #include "wx/fs_zip.h"
3277 #include "wx/zipstrm.h"
3278
3279 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3280
3281 static void TestZipStreamRead()
3282 {
3283     wxPuts(_T("*** Testing ZIP reading ***\n"));
3284
3285     static const wxString filename = _T("foo");
3286     wxZipInputStream istr(TESTFILE_ZIP, filename);
3287     wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
3288
3289     wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
3290     while ( !istr.Eof() )
3291     {
3292         wxPutchar(istr.GetC());
3293         fflush(stdout);
3294     }
3295
3296     wxPuts(_T("\n----- done ------"));
3297 }
3298
3299 static void DumpZipDirectory(wxFileSystem& fs,
3300                              const wxString& dir,
3301                              const wxString& indent)
3302 {
3303     wxString prefix = wxString::Format(_T("%s#zip:%s"),
3304                                          TESTFILE_ZIP, dir.c_str());
3305     wxString wildcard = prefix + _T("/*");
3306
3307     wxString dirname = fs.FindFirst(wildcard, wxDIR);
3308     while ( !dirname.empty() )
3309     {
3310         if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3311         {
3312             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3313
3314             break;
3315         }
3316
3317         wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3318
3319         DumpZipDirectory(fs, dirname,
3320                          indent + wxString(_T(' '), 4));
3321
3322         dirname = fs.FindNext();
3323     }
3324
3325     wxString filename = fs.FindFirst(wildcard, wxFILE);
3326     while ( !filename.empty() )
3327     {
3328         if ( !filename.StartsWith(prefix, &filename) )
3329         {
3330             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3331
3332             break;
3333         }
3334
3335         wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3336
3337         filename = fs.FindNext();
3338     }
3339 }
3340
3341 static void TestZipFileSystem()
3342 {
3343     wxPuts(_T("*** Testing ZIP file system ***\n"));
3344
3345     wxFileSystem::AddHandler(new wxZipFSHandler);
3346     wxFileSystem fs;
3347     wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3348
3349     DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3350 }
3351
3352 #endif // TEST_ZIP
3353
3354 // ----------------------------------------------------------------------------
3355 // date time
3356 // ----------------------------------------------------------------------------
3357
3358 #ifdef TEST_DATETIME
3359
3360 #include "wx/math.h"
3361 #include "wx/datetime.h"
3362
3363 // this test miscellaneous static wxDateTime functions
3364
3365 #if TEST_ALL
3366
3367 static void TestTimeStatic()
3368 {
3369     wxPuts(_T("\n*** wxDateTime static methods test ***"));
3370
3371     // some info about the current date
3372     int year = wxDateTime::GetCurrentYear();
3373     wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
3374            year,
3375            wxDateTime::IsLeapYear(year) ? "" : "not ",
3376            wxDateTime::GetNumberOfDays(year));
3377
3378     wxDateTime::Month month = wxDateTime::GetCurrentMonth();
3379     wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
3380            wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
3381            wxDateTime::GetMonthName(month).c_str(),
3382            wxDateTime::GetNumberOfDays(month));
3383 }
3384
3385 // test time zones stuff
3386 static void TestTimeZones()
3387 {
3388     wxPuts(_T("\n*** wxDateTime timezone test ***"));
3389
3390     wxDateTime now = wxDateTime::Now();
3391
3392     wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
3393     wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
3394     wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
3395     wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
3396     wxPrintf(_T("               Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
3397     wxPrintf(_T("             New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
3398
3399     wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3400
3401     wxDateTime::Tm tm = now.GetTm();
3402     if ( wxDateTime(tm) != now )
3403     {
3404         wxPrintf(_T("ERROR: got %s instead of %s\n"),
3405                  wxDateTime(tm).Format().c_str(), now.Format().c_str());
3406     }
3407 }
3408
3409 // test some minimal support for the dates outside the standard range
3410 static void TestTimeRange()
3411 {
3412     wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
3413
3414     static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
3415
3416     wxPrintf(_T("Unix epoch:\t%s\n"),
3417              wxDateTime(2440587.5).Format(fmt).c_str());
3418     wxPrintf(_T("Feb 29, 0: \t%s\n"),
3419              wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3420     wxPrintf(_T("JDN 0:     \t%s\n"),
3421              wxDateTime(0.0).Format(fmt).c_str());
3422     wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3423              wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3424     wxPrintf(_T("May 29, 2099:\t%s\n"),
3425              wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
3426 }
3427
3428 // test DST calculations
3429 static void TestTimeDST()
3430 {
3431     wxPuts(_T("\n*** wxDateTime DST test ***"));
3432
3433     wxPrintf(_T("DST is%s in effect now.\n\n"),
3434              wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
3435
3436     for ( int year = 1990; year < 2005; year++ )
3437     {
3438         wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3439                  year,
3440                  wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3441                  wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
3442     }
3443 }
3444
3445 #endif // TEST_ALL
3446
3447 #if TEST_INTERACTIVE
3448
3449 static void TestDateTimeInteractive()
3450 {
3451     wxPuts(_T("\n*** interactive wxDateTime tests ***"));
3452
3453     wxChar buf[128];
3454
3455     for ( ;; )
3456     {
3457         wxPrintf(_T("Enter a date: "));
3458         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
3459             break;
3460
3461         // kill the last '\n'
3462         buf[wxStrlen(buf) - 1] = 0;
3463
3464         wxDateTime dt;
3465         const wxChar *p = dt.ParseDate(buf);
3466         if ( !p )
3467         {
3468             wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
3469
3470             continue;
3471         }
3472         else if ( *p )
3473         {
3474             wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
3475         }
3476
3477         wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3478                  dt.Format(_T("%b %d, %Y")).c_str(),
3479                  dt.GetDayOfYear(),
3480                  dt.GetWeekOfMonth(wxDateTime::Monday_First),
3481                  dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3482                  dt.GetWeekOfYear(wxDateTime::Monday_First));
3483     }
3484
3485     wxPuts(_T("\n*** done ***"));
3486 }
3487
3488 #endif // TEST_INTERACTIVE
3489
3490 #if TEST_ALL
3491
3492 static void TestTimeMS()
3493 {
3494     wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
3495
3496     wxDateTime dt1 = wxDateTime::Now(),
3497                dt2 = wxDateTime::UNow();
3498
3499     wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
3500     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3501     wxPrintf(_T("Dummy loop: "));
3502     for ( int i = 0; i < 6000; i++ )
3503     {
3504         //for ( int j = 0; j < 10; j++ )
3505         {
3506             wxString s;
3507             s.Printf(_T("%g"), sqrt((float)i));
3508         }
3509
3510         if ( !(i % 100) )
3511             wxPutchar('.');
3512     }
3513     wxPuts(_T(", done"));
3514
3515     dt1 = dt2;
3516     dt2 = wxDateTime::UNow();
3517     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3518
3519     wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
3520
3521     wxPuts(_T("\n*** done ***"));
3522 }
3523
3524 static void TestTimeHolidays()
3525 {
3526     wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
3527
3528     wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3529     wxDateTime dtStart(1, tm.mon, tm.year),
3530                dtEnd = dtStart.GetLastMonthDay();
3531
3532     wxDateTimeArray hol;
3533     wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3534
3535     const wxChar *format = _T("%d-%b-%Y (%a)");
3536
3537     wxPrintf(_T("All holidays between %s and %s:\n"),
3538            dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3539
3540     size_t count = hol.GetCount();
3541     for ( size_t n = 0; n < count; n++ )
3542     {
3543         wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
3544     }
3545
3546     wxPuts(wxEmptyString);
3547 }
3548
3549 static void TestTimeZoneBug()
3550 {
3551     wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
3552
3553     wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3554     for ( int i = 0; i < 31; i++ )
3555     {
3556         wxPrintf(_T("Date %s: week day %s.\n"),
3557                date.Format(_T("%d-%m-%Y")).c_str(),
3558                date.GetWeekDayName(date.GetWeekDay()).c_str());
3559
3560         date += wxDateSpan::Day();
3561     }
3562
3563     wxPuts(wxEmptyString);
3564 }
3565
3566 static void TestTimeSpanFormat()
3567 {
3568     wxPuts(_T("\n*** wxTimeSpan tests ***"));
3569
3570     static const wxChar *formats[] =
3571     {
3572         _T("(default) %H:%M:%S"),
3573         _T("%E weeks and %D days"),
3574         _T("%l milliseconds"),
3575         _T("(with ms) %H:%M:%S:%l"),
3576         _T("100%% of minutes is %M"),       // test "%%"
3577         _T("%D days and %H hours"),
3578         _T("or also %S seconds"),
3579     };
3580
3581     wxTimeSpan ts1(1, 2, 3, 4),
3582                 ts2(111, 222, 333);
3583     for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3584     {
3585         wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
3586                ts1.Format(formats[n]).c_str(),
3587                ts2.Format(formats[n]).c_str());
3588     }
3589
3590     wxPuts(wxEmptyString);
3591 }
3592
3593 #endif // TEST_ALL
3594
3595 #endif // TEST_DATETIME
3596
3597 // ----------------------------------------------------------------------------
3598 // wxTextInput/OutputStream
3599 // ----------------------------------------------------------------------------
3600
3601 #ifdef TEST_TEXTSTREAM
3602
3603 #include "wx/txtstrm.h"
3604 #include "wx/wfstream.h"
3605
3606 static void TestTextInputStream()
3607 {
3608     wxPuts(_T("\n*** wxTextInputStream test ***"));
3609
3610     wxString filename = _T("testdata.fc");
3611     wxFileInputStream fsIn(filename);
3612     if ( !fsIn.Ok() )
3613     {
3614         wxPuts(_T("ERROR: couldn't open file."));
3615     }
3616     else
3617     {
3618         wxTextInputStream tis(fsIn);
3619
3620         size_t line = 1;
3621         for ( ;; )
3622         {
3623             const wxString s = tis.ReadLine();
3624
3625             // line could be non empty if the last line of the file isn't
3626             // terminated with EOL
3627             if ( fsIn.Eof() && s.empty() )
3628                 break;
3629
3630             wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
3631         }
3632     }
3633 }
3634
3635 #endif // TEST_TEXTSTREAM
3636
3637 // ----------------------------------------------------------------------------
3638 // threads
3639 // ----------------------------------------------------------------------------
3640
3641 #ifdef TEST_THREADS
3642
3643 #include "wx/thread.h"
3644
3645 static size_t gs_counter = (size_t)-1;
3646 static wxCriticalSection gs_critsect;
3647 static wxSemaphore gs_cond;
3648
3649 class MyJoinableThread : public wxThread
3650 {
3651 public:
3652     MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3653         { m_n = n; Create(); }
3654
3655     // thread execution starts here
3656     virtual ExitCode Entry();
3657
3658 private:
3659     size_t m_n;
3660 };
3661
3662 wxThread::ExitCode MyJoinableThread::Entry()
3663 {
3664     unsigned long res = 1;
3665     for ( size_t n = 1; n < m_n; n++ )
3666     {
3667         res *= n;
3668
3669         // it's a loooong calculation :-)
3670         Sleep(100);
3671     }
3672
3673     return (ExitCode)res;
3674 }
3675
3676 class MyDetachedThread : public wxThread
3677 {
3678 public:
3679     MyDetachedThread(size_t n, wxChar ch)
3680     {
3681         m_n = n;
3682         m_ch = ch;
3683         m_cancelled = false;
3684
3685         Create();
3686     }
3687
3688     // thread execution starts here
3689     virtual ExitCode Entry();
3690
3691     // and stops here
3692     virtual void OnExit();
3693
3694 private:
3695     size_t m_n; // number of characters to write
3696     wxChar m_ch;  // character to write
3697
3698     bool m_cancelled;   // false if we exit normally
3699 };
3700
3701 wxThread::ExitCode MyDetachedThread::Entry()
3702 {
3703     {
3704         wxCriticalSectionLocker lock(gs_critsect);
3705         if ( gs_counter == (size_t)-1 )
3706             gs_counter = 1;
3707         else
3708             gs_counter++;
3709     }
3710
3711     for ( size_t n = 0; n < m_n; n++ )
3712     {
3713         if ( TestDestroy() )
3714         {
3715             m_cancelled = true;
3716
3717             break;
3718         }
3719
3720         wxPutchar(m_ch);
3721         fflush(stdout);
3722
3723         wxThread::Sleep(100);
3724     }
3725
3726     return 0;
3727 }
3728
3729 void MyDetachedThread::OnExit()
3730 {
3731     wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
3732
3733     wxCriticalSectionLocker lock(gs_critsect);
3734     if ( !--gs_counter && !m_cancelled )
3735         gs_cond.Post();
3736 }
3737
3738 static void TestDetachedThreads()
3739 {
3740     wxPuts(_T("\n*** Testing detached threads ***"));
3741
3742     static const size_t nThreads = 3;
3743     MyDetachedThread *threads[nThreads];
3744     size_t n;
3745     for ( n = 0; n < nThreads; n++ )
3746     {
3747         threads[n] = new MyDetachedThread(10, 'A' + n);
3748     }
3749
3750     threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
3751     threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
3752
3753     for ( n = 0; n < nThreads; n++ )
3754     {
3755         threads[n]->Run();
3756     }
3757
3758     // wait until all threads terminate
3759     gs_cond.Wait();
3760
3761     wxPuts(wxEmptyString);
3762 }
3763
3764 static void TestJoinableThreads()
3765 {
3766     wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
3767
3768     // calc 10! in the background
3769     MyJoinableThread thread(10);
3770     thread.Run();
3771
3772     wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
3773              (unsigned long)thread.Wait());
3774 }
3775
3776 static void TestThreadSuspend()
3777 {
3778     wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
3779
3780     MyDetachedThread *thread = new MyDetachedThread(15, 'X');
3781
3782     thread->Run();
3783
3784     // this is for this demo only, in a real life program we'd use another
3785     // condition variable which would be signaled from wxThread::Entry() to
3786     // tell us that the thread really started running - but here just wait a
3787     // bit and hope that it will be enough (the problem is, of course, that
3788     // the thread might still not run when we call Pause() which will result
3789     // in an error)
3790     wxThread::Sleep(300);
3791
3792     for ( size_t n = 0; n < 3; n++ )
3793     {
3794         thread->Pause();
3795
3796         wxPuts(_T("\nThread suspended"));
3797         if ( n > 0 )
3798         {
3799             // don't sleep but resume immediately the first time
3800             wxThread::Sleep(300);
3801         }
3802         wxPuts(_T("Going to resume the thread"));
3803
3804         thread->Resume();
3805     }
3806
3807     wxPuts(_T("Waiting until it terminates now"));
3808
3809     // wait until the thread terminates
3810     gs_cond.Wait();
3811
3812     wxPuts(wxEmptyString);
3813 }
3814
3815 static void TestThreadDelete()
3816 {
3817     // As above, using Sleep() is only for testing here - we must use some
3818     // synchronisation object instead to ensure that the thread is still
3819     // running when we delete it - deleting a detached thread which already
3820     // terminated will lead to a crash!
3821
3822     wxPuts(_T("\n*** Testing thread delete function ***"));
3823
3824     MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
3825
3826     thread0->Delete();
3827
3828     wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
3829
3830     MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
3831
3832     thread1->Run();
3833
3834     wxThread::Sleep(300);
3835
3836     thread1->Delete();
3837
3838     wxPuts(_T("\nDeleted a running thread."));
3839
3840     MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
3841
3842     thread2->Run();
3843
3844     wxThread::Sleep(300);
3845
3846     thread2->Pause();
3847
3848     thread2->Delete();
3849
3850     wxPuts(_T("\nDeleted a sleeping thread."));
3851
3852     MyJoinableThread thread3(20);
3853     thread3.Run();
3854
3855     thread3.Delete();
3856
3857     wxPuts(_T("\nDeleted a joinable thread."));
3858
3859     MyJoinableThread thread4(2);
3860     thread4.Run();
3861
3862     wxThread::Sleep(300);
3863
3864     thread4.Delete();
3865
3866     wxPuts(_T("\nDeleted a joinable thread which already terminated."));
3867
3868     wxPuts(wxEmptyString);
3869 }
3870
3871 class MyWaitingThread : public wxThread
3872 {
3873 public:
3874     MyWaitingThread( wxMutex *mutex, wxCondition *condition )
3875     {
3876         m_mutex = mutex;
3877         m_condition = condition;
3878
3879         Create();
3880     }
3881
3882     virtual ExitCode Entry()
3883     {
3884         wxPrintf(_T("Thread %lu has started running.\n"), GetId());
3885         fflush(stdout);
3886
3887         gs_cond.Post();
3888
3889         wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
3890         fflush(stdout);
3891
3892         m_mutex->Lock();
3893         m_condition->Wait();
3894         m_mutex->Unlock();
3895
3896         wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
3897         fflush(stdout);
3898
3899         return 0;
3900     }
3901
3902 private:
3903     wxMutex *m_mutex;
3904     wxCondition *m_condition;
3905 };
3906
3907 static void TestThreadConditions()
3908 {
3909     wxMutex mutex;
3910     wxCondition condition(mutex);
3911
3912     // otherwise its difficult to understand which log messages pertain to
3913     // which condition
3914     //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
3915     //           condition.GetId(), gs_cond.GetId());
3916
3917     // create and launch threads
3918     MyWaitingThread *threads[10];
3919
3920     size_t n;
3921     for ( n = 0; n < WXSIZEOF(threads); n++ )
3922     {
3923         threads[n] = new MyWaitingThread( &mutex, &condition );
3924     }
3925
3926     for ( n = 0; n < WXSIZEOF(threads); n++ )
3927     {
3928         threads[n]->Run();
3929     }
3930
3931     // wait until all threads run
3932     wxPuts(_T("Main thread is waiting for the other threads to start"));
3933     fflush(stdout);
3934
3935     size_t nRunning = 0;
3936     while ( nRunning < WXSIZEOF(threads) )
3937     {
3938         gs_cond.Wait();
3939
3940         nRunning++;
3941
3942         wxPrintf(_T("Main thread: %u already running\n"), nRunning);
3943         fflush(stdout);
3944     }
3945
3946     wxPuts(_T("Main thread: all threads started up."));
3947     fflush(stdout);
3948
3949     wxThread::Sleep(500);
3950
3951 #if 1
3952     // now wake one of them up
3953     wxPrintf(_T("Main thread: about to signal the condition.\n"));
3954     fflush(stdout);
3955     condition.Signal();
3956 #endif
3957
3958     wxThread::Sleep(200);
3959
3960     // wake all the (remaining) threads up, so that they can exit
3961     wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
3962     fflush(stdout);
3963     condition.Broadcast();
3964
3965     // give them time to terminate (dirty!)
3966     wxThread::Sleep(500);
3967 }
3968
3969 #include "wx/utils.h"
3970
3971 class MyExecThread : public wxThread
3972 {
3973 public:
3974     MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
3975                                             m_command(command)
3976     {
3977         Create();
3978     }
3979
3980     virtual ExitCode Entry()
3981     {
3982         return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
3983     }
3984
3985 private:
3986     wxString m_command;
3987 };
3988
3989 static void TestThreadExec()
3990 {
3991     wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
3992
3993     MyExecThread thread(_T("true"));
3994     thread.Run();
3995
3996     wxPrintf(_T("Main program exit code: %ld.\n"),
3997              wxExecute(_T("false"), wxEXEC_SYNC));
3998
3999     wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
4000 }
4001
4002 // semaphore tests
4003 #include "wx/datetime.h"
4004
4005 class MySemaphoreThread : public wxThread
4006 {
4007 public:
4008     MySemaphoreThread(int i, wxSemaphore *sem)
4009         : wxThread(wxTHREAD_JOINABLE),
4010           m_sem(sem),
4011           m_i(i)
4012     {
4013         Create();
4014     }
4015
4016     virtual ExitCode Entry()
4017     {
4018         wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
4019                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4020
4021         m_sem->Wait();
4022
4023         wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
4024                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4025
4026         Sleep(1000);
4027
4028         wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
4029                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4030
4031         m_sem->Post();
4032
4033         return 0;
4034     }
4035
4036 private:
4037     wxSemaphore *m_sem;
4038     int m_i;
4039 };
4040
4041 WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
4042
4043 static void TestSemaphore()
4044 {
4045     wxPuts(_T("*** Testing wxSemaphore class. ***"));
4046
4047     static const int SEM_LIMIT = 3;
4048
4049     wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
4050     ArrayThreads threads;
4051
4052     for ( int i = 0; i < 3*SEM_LIMIT; i++ )
4053     {
4054         threads.Add(new MySemaphoreThread(i, &sem));
4055         threads.Last()->Run();
4056     }
4057
4058     for ( size_t n = 0; n < threads.GetCount(); n++ )
4059     {
4060         threads[n]->Wait();
4061         delete threads[n];
4062     }
4063 }
4064
4065 #endif // TEST_THREADS
4066
4067 // ----------------------------------------------------------------------------
4068 // entry point
4069 // ----------------------------------------------------------------------------
4070
4071 #ifdef TEST_SNGLINST
4072     #include "wx/snglinst.h"
4073 #endif // TEST_SNGLINST
4074
4075 int main(int argc, char **argv)
4076 {
4077     wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
4078
4079     wxInitializer initializer;
4080     if ( !initializer )
4081     {
4082         fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
4083
4084         return -1;
4085     }
4086
4087 #ifdef TEST_SNGLINST
4088     wxSingleInstanceChecker checker;
4089     if ( checker.Create(_T(".wxconsole.lock")) )
4090     {
4091         if ( checker.IsAnotherRunning() )
4092         {
4093             wxPrintf(_T("Another instance of the program is running, exiting.\n"));
4094
4095             return 1;
4096         }
4097
4098         // wait some time to give time to launch another instance
4099         wxPrintf(_T("Press \"Enter\" to continue..."));
4100         wxFgetc(stdin);
4101     }
4102     else // failed to create
4103     {
4104         wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
4105     }
4106 #endif // TEST_SNGLINST
4107
4108 #ifdef TEST_CMDLINE
4109     TestCmdLineConvert();
4110
4111 #if wxUSE_CMDLINE_PARSER
4112     static const wxCmdLineEntryDesc cmdLineDesc[] =
4113     {
4114         { wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
4115             wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
4116         { wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
4117         { wxCMD_LINE_SWITCH, _T("q"), _T("quiet"),   _T("be quiet") },
4118
4119         { wxCMD_LINE_OPTION, _T("o"), _T("output"),  _T("output file") },
4120         { wxCMD_LINE_OPTION, _T("i"), _T("input"),   _T("input dir") },
4121         { wxCMD_LINE_OPTION, _T("s"), _T("size"),    _T("output block size"),
4122             wxCMD_LINE_VAL_NUMBER },
4123         { wxCMD_LINE_OPTION, _T("d"), _T("date"),    _T("output file date"),
4124             wxCMD_LINE_VAL_DATE },
4125
4126         { wxCMD_LINE_PARAM,  NULL, NULL, _T("input file"),
4127             wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
4128
4129         { wxCMD_LINE_NONE }
4130     };
4131
4132 #if wxUSE_UNICODE
4133     wxChar **wargv = new wxChar *[argc + 1];
4134
4135     {
4136         int n;
4137
4138         for (n = 0; n < argc; n++ )
4139         {
4140             wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
4141             wargv[n] = wxStrdup(warg);
4142         }
4143
4144         wargv[n] = NULL;
4145     }
4146
4147     #define argv wargv
4148 #endif // wxUSE_UNICODE
4149
4150     wxCmdLineParser parser(cmdLineDesc, argc, argv);
4151
4152 #if wxUSE_UNICODE
4153     {
4154         for ( int n = 0; n < argc; n++ )
4155             free(wargv[n]);
4156
4157         delete [] wargv;
4158     }
4159 #endif // wxUSE_UNICODE
4160
4161     parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
4162                      wxCMD_LINE_VAL_STRING,
4163                      wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
4164
4165     switch ( parser.Parse() )
4166     {
4167         case -1:
4168             wxLogMessage(_T("Help was given, terminating."));
4169             break;
4170
4171         case 0:
4172             ShowCmdLine(parser);
4173             break;
4174
4175         default:
4176             wxLogMessage(_T("Syntax error detected, aborting."));
4177             break;
4178     }
4179 #endif // wxUSE_CMDLINE_PARSER
4180
4181 #endif // TEST_CMDLINE
4182
4183 #ifdef TEST_DIR
4184     #if TEST_ALL
4185         TestDirExists();
4186         TestDirEnum();
4187     #endif
4188     TestDirTraverse();
4189 #endif // TEST_DIR
4190
4191 #ifdef TEST_DLLLOADER
4192     TestDllLoad();
4193     TestDllListLoaded();
4194 #endif // TEST_DLLLOADER
4195
4196 #ifdef TEST_ENVIRON
4197     TestEnvironment();
4198 #endif // TEST_ENVIRON
4199
4200 #ifdef TEST_EXECUTE
4201     TestExecute();
4202 #endif // TEST_EXECUTE
4203
4204 #ifdef TEST_FILECONF
4205     TestFileConfRead();
4206 #endif // TEST_FILECONF
4207
4208 #ifdef TEST_LOCALE
4209     TestDefaultLang();
4210 #endif // TEST_LOCALE
4211
4212 #ifdef TEST_LOG
4213     wxPuts(_T("*** Testing wxLog ***"));
4214
4215     wxString s;
4216     for ( size_t n = 0; n < 8000; n++ )
4217     {
4218         s << (wxChar)(_T('A') + (n % 26));
4219     }
4220
4221     wxLogWarning(_T("The length of the string is %lu"),
4222                  (unsigned long)s.length());
4223
4224     wxString msg;
4225     msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
4226
4227     // this one shouldn't be truncated
4228     wxPrintf(msg);
4229
4230     // but this one will because log functions use fixed size buffer
4231     // (note that it doesn't need '\n' at the end neither - will be added
4232     //  by wxLog anyhow)
4233     wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
4234 #endif // TEST_LOG
4235
4236 #ifdef TEST_FILE
4237     TestFileRead();
4238     TestTextFileRead();
4239     TestFileCopy();
4240 #endif // TEST_FILE
4241
4242 #ifdef TEST_FILENAME
4243     TestFileNameConstruction();
4244     TestFileNameMakeRelative();
4245     TestFileNameMakeAbsolute();
4246     TestFileNameSplit();
4247     TestFileNameTemp();
4248     TestFileNameCwd();
4249     TestFileNameDirManip();
4250     TestFileNameComparison();
4251     TestFileNameOperations();
4252 #endif // TEST_FILENAME
4253
4254 #ifdef TEST_FILETIME
4255     TestFileGetTimes();
4256     #if 0
4257     TestFileSetTimes();
4258     #endif
4259 #endif // TEST_FILETIME
4260
4261 #ifdef TEST_FTP
4262     wxLog::AddTraceMask(FTP_TRACE_MASK);
4263     if ( TestFtpConnect() )
4264     {
4265         #if TEST_ALL
4266             TestFtpList();
4267             TestFtpDownload();
4268             TestFtpMisc();
4269             TestFtpFileSize();
4270             TestFtpUpload();
4271         #endif // TEST_ALL
4272
4273         #if TEST_INTERACTIVE
4274             TestFtpInteractive();
4275         #endif
4276     }
4277     //else: connecting to the FTP server failed
4278
4279     #if 0
4280         TestFtpWuFtpd();
4281     #endif
4282 #endif // TEST_FTP
4283
4284 #ifdef TEST_MIME
4285     wxLog::AddTraceMask(_T("mime"));
4286     #if TEST_ALL
4287         TestMimeEnum();
4288         TestMimeOverride();
4289         TestMimeAssociate();
4290     #endif
4291     TestMimeFilename();
4292 #endif // TEST_MIME
4293
4294 #ifdef TEST_INFO_FUNCTIONS
4295     #if TEST_ALL
4296         TestOsInfo();
4297         TestUserInfo();
4298
4299         #if TEST_INTERACTIVE
4300             TestDiskInfo();
4301         #endif
4302     #endif
4303 #endif // TEST_INFO_FUNCTIONS
4304
4305 #ifdef TEST_PATHLIST
4306     TestPathList();
4307 #endif // TEST_PATHLIST
4308
4309 #ifdef TEST_ODBC
4310     TestDbOpen();
4311 #endif // TEST_ODBC
4312
4313 #ifdef TEST_PRINTF
4314     TestPrintf();
4315 #endif // TEST_PRINTF
4316
4317 #ifdef TEST_REGCONF
4318     #if 0
4319     TestRegConfWrite();
4320     #endif
4321     TestRegConfRead();
4322 #endif // TEST_REGCONF
4323
4324 #if defined TEST_REGEX && TEST_INTERACTIVE
4325     TestRegExInteractive();
4326 #endif // defined TEST_REGEX && TEST_INTERACTIVE
4327
4328 #ifdef TEST_REGISTRY
4329     TestRegistryRead();
4330     TestRegistryAssociation();
4331 #endif // TEST_REGISTRY
4332
4333 #ifdef TEST_SOCKETS
4334     TestSocketServer();
4335     TestSocketClient();
4336 #endif // TEST_SOCKETS
4337
4338 #ifdef TEST_STREAMS
4339     #if TEST_ALL
4340         TestFileStream();
4341     #endif
4342         TestMemoryStream();
4343 #endif // TEST_STREAMS
4344
4345 #ifdef TEST_TEXTSTREAM
4346     TestTextInputStream();
4347 #endif // TEST_TEXTSTREAM
4348
4349 #ifdef TEST_THREADS
4350     int nCPUs = wxThread::GetCPUCount();
4351     wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
4352     if ( nCPUs != -1 )
4353         wxThread::SetConcurrency(nCPUs);
4354
4355         TestJoinableThreads();
4356
4357     #if TEST_ALL
4358         TestJoinableThreads();
4359         TestDetachedThreads();
4360         TestThreadSuspend();
4361         TestThreadDelete();
4362         TestThreadConditions();
4363         TestThreadExec();
4364         TestSemaphore();
4365     #endif
4366 #endif // TEST_THREADS
4367
4368 #ifdef TEST_TIMER
4369     TestStopWatch();
4370 #endif // TEST_TIMER
4371
4372 #ifdef TEST_DATETIME
4373     #if TEST_ALL
4374         TestTimeSet();
4375         TestTimeStatic();
4376         TestTimeRange();
4377         TestTimeZones();
4378         TestTimeTicks();
4379         TestTimeJDN();
4380         TestTimeDST();
4381         TestTimeWDays();
4382         TestTimeWNumber();
4383         TestTimeParse();
4384         TestTimeArithmetics();
4385         TestTimeHolidays();
4386         TestTimeSpanFormat();
4387         TestTimeMS();
4388
4389         TestTimeZoneBug();
4390     #endif
4391
4392     #if TEST_INTERACTIVE
4393         TestDateTimeInteractive();
4394     #endif
4395 #endif // TEST_DATETIME
4396
4397 #ifdef TEST_SCOPEGUARD
4398     TestScopeGuard();
4399 #endif
4400
4401 #ifdef TEST_STACKWALKER
4402     TestStackWalk(argv[0]);
4403 #endif // TEST_STACKWALKER
4404
4405 #ifdef TEST_STDPATHS
4406     TestStandardPaths();
4407 #endif
4408
4409 #ifdef TEST_USLEEP
4410     wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
4411     wxUsleep(3000);
4412 #endif // TEST_USLEEP
4413
4414 #ifdef TEST_VCARD
4415     TestVCardRead();
4416     TestVCardWrite();
4417 #endif // TEST_VCARD
4418
4419 #ifdef TEST_VOLUME
4420     TestFSVolume();
4421 #endif // TEST_VOLUME
4422
4423 #ifdef TEST_WCHAR
4424     TestUtf8();
4425     TestEncodingConverter();
4426 #endif // TEST_WCHAR
4427
4428 #ifdef TEST_ZIP
4429     TestZipStreamRead();
4430     TestZipFileSystem();
4431 #endif // TEST_ZIP
4432
4433     wxUnusedVar(argc);
4434     wxUnusedVar(argv);
4435     return 0;
4436 }
4437