samples/console/console.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/console/console.cpp
   3 // Purpose:     a sample console (as opposed to GUI) progam using wxWindows
   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 wxWindows 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)? uncomment the line below to do all tests
  48 //#define TEST_ALL
  49 #ifdef TEST_ALL
  50     #define TEST_ARRAYS
  51     #define TEST_CHARSET
  52     #define TEST_CMDLINE
  53     #define TEST_DATETIME
  54     #define TEST_DIR
  55     #define TEST_DLLLOADER
  56     #define TEST_ENVIRON
  57     #define TEST_EXECUTE
  58     #define TEST_FILE
  59     #define TEST_FILECONF
  60     #define TEST_FILENAME
  61     #define TEST_FILETIME
  62     #define TEST_FTP
  63     #define TEST_HASH
  64     #define TEST_HASHMAP
  65     #define TEST_HASHSET
  66     #define TEST_INFO_FUNCTIONS
  67     #define TEST_LIST
  68     #define TEST_LOCALE
  69     #define TEST_LOG
  70     #define TEST_LONGLONG
  71     #define TEST_MIME
  72     #define TEST_PATHLIST
  73     #define TEST_ODBC
  74     #define TEST_PRINTF
  75     #define TEST_REGCONF
  76     #define TEST_REGEX
  77     #define TEST_REGISTRY
  78     #define TEST_SCOPEGUARD
  79     #define TEST_SNGLINST
  80     #define TEST_SOCKETS
  81     #define TEST_STREAMS
  82     #define TEST_STRINGS
  83     #define TEST_TEXTSTREAM
  84     #define TEST_THREADS
  85     #define TEST_TIMER
  86     #define TEST_UNICODE
  87     // #define TEST_VCARD            -- don't enable this (VZ)
  88     #define TEST_VOLUME
  89     #define TEST_WCHAR
  90     #define TEST_ZIP
  91     #define TEST_ZLIB
  92
  93     #undef TEST_ALL
  94     static const bool TEST_ALL = true;
  95 #else
  96     #define TEST_STRINGS
  97
  98     static const bool TEST_ALL = false;
  99 #endif
 100
 101 // some tests are interactive, define this to run them
 102 #ifdef TEST_INTERACTIVE
 103     #undef TEST_INTERACTIVE
 104
 105     static const bool TEST_INTERACTIVE = true;
 106 #else
 107     static const bool TEST_INTERACTIVE = false;
 108 #endif
 109
 110 // ----------------------------------------------------------------------------
 111 // test class for container objects
 112 // ----------------------------------------------------------------------------
 113
 114 #if defined(TEST_ARRAYS) || defined(TEST_LIST)
 115
 116 class Bar // Foo is already taken in the hash test
 117 {
 118 public:
 119     Bar(const wxString& name) : m_name(name) { ms_bars++; }
 120     Bar(const Bar& bar) : m_name(bar.m_name) { ms_bars++; }
 121    ~Bar() { ms_bars--; }
 122
 123    static size_t GetNumber() { return ms_bars; }
 124
 125    const wxChar *GetName() const { return m_name; }
 126
 127 private:
 128    wxString m_name;
 129
 130    static size_t ms_bars;
 131 };
 132
 133 size_t Bar::ms_bars = 0;
 134
 135 #endif // defined(TEST_ARRAYS) || defined(TEST_LIST)
 136
 137 // ============================================================================
 138 // implementation
 139 // ============================================================================
 140
 141 // ----------------------------------------------------------------------------
 142 // helper functions
 143 // ----------------------------------------------------------------------------
 144
 145 #if defined(TEST_STRINGS) || defined(TEST_SOCKETS)
 146
 147 // replace TABs with \t and CRs with \n
 148 static wxString MakePrintable(const wxChar *s)
 149 {
 150     wxString str(s);
 151     (void)str.Replace(_T("\t"), _T("\\t"));
 152     (void)str.Replace(_T("\n"), _T("\\n"));
 153     (void)str.Replace(_T("\r"), _T("\\r"));
 154
 155     return str;
 156 }
 157
 158 #endif // MakePrintable() is used
 159
 160 // ----------------------------------------------------------------------------
 161 // wxFontMapper::CharsetToEncoding
 162 // ----------------------------------------------------------------------------
 163
 164 #ifdef TEST_CHARSET
 165
 166 #include "wx/fontmap.h"
 167
 168 static void TestCharset()
 169 {
 170     static const wxChar *charsets[] =
 171     {
 172         // some vali charsets
 173         _T("us-ascii    "),
 174         _T("iso8859-1   "),
 175         _T("iso-8859-12 "),
 176         _T("koi8-r      "),
 177         _T("utf-7       "),
 178         _T("cp1250      "),
 179         _T("windows-1252"),
 180
 181         // and now some bogus ones
 182         _T("            "),
 183         _T("cp1249      "),
 184         _T("iso--8859-1 "),
 185         _T("iso-8859-19 "),
 186     };
 187
 188     for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
 189     {
 190         wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charsets[n]);
 191         wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
 192                  charsets[n],
 193                  wxFontMapper::Get()->GetEncodingName(enc).c_str(),
 194                  wxFontMapper::Get()->GetEncodingDescription(enc).c_str());
 195     }
 196 }
 197
 198 #endif // TEST_CHARSET
 199
 200 // ----------------------------------------------------------------------------
 201 // wxCmdLineParser
 202 // ----------------------------------------------------------------------------
 203
 204 #ifdef TEST_CMDLINE
 205
 206 #include "wx/cmdline.h"
 207 #include "wx/datetime.h"
 208
 209 #if wxUSE_CMDLINE_PARSER
 210
 211 static void ShowCmdLine(const wxCmdLineParser& parser)
 212 {
 213     wxString s = _T("Input files: ");
 214
 215     size_t count = parser.GetParamCount();
 216     for ( size_t param = 0; param < count; param++ )
 217     {
 218         s << parser.GetParam(param) << ' ';
 219     }
 220
 221     s << '\n'
 222       << _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
 223       << _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
 224
 225     wxString strVal;
 226     long lVal;
 227     wxDateTime dt;
 228     if ( parser.Found(_T("o"), &strVal) )
 229         s << _T("Output file:\t") << strVal << '\n';
 230     if ( parser.Found(_T("i"), &strVal) )
 231         s << _T("Input dir:\t") << strVal << '\n';
 232     if ( parser.Found(_T("s"), &lVal) )
 233         s << _T("Size:\t") << lVal << '\n';
 234     if ( parser.Found(_T("d"), &dt) )
 235         s << _T("Date:\t") << dt.FormatISODate() << '\n';
 236     if ( parser.Found(_T("project_name"), &strVal) )
 237         s << _T("Project:\t") << strVal << '\n';
 238
 239     wxLogMessage(s);
 240 }
 241
 242 #endif // wxUSE_CMDLINE_PARSER
 243
 244 static void TestCmdLineConvert()
 245 {
 246     static const wxChar *cmdlines[] =
 247     {
 248         _T("arg1 arg2"),
 249         _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
 250         _T("literal \\\" and \"\""),
 251     };
 252
 253     for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
 254     {
 255         const wxChar *cmdline = cmdlines[n];
 256         wxPrintf(_T("Parsing: %s\n"), cmdline);
 257         wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
 258
 259         size_t count = args.GetCount();
 260         wxPrintf(_T("\targc = %u\n"), count);
 261         for ( size_t arg = 0; arg < count; arg++ )
 262         {
 263             wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
 264         }
 265     }
 266 }
 267
 268 #endif // TEST_CMDLINE
 269
 270 // ----------------------------------------------------------------------------
 271 // wxDir
 272 // ----------------------------------------------------------------------------
 273
 274 #ifdef TEST_DIR
 275
 276 #include "wx/dir.h"
 277
 278 #ifdef __UNIX__
 279     static const wxChar *ROOTDIR = _T("/");
 280     static const wxChar *TESTDIR = _T("/usr/local/share");
 281 #elif defined(__WXMSW__)
 282     static const wxChar *ROOTDIR = _T("c:\\");
 283     static const wxChar *TESTDIR = _T("d:\\");
 284 #else
 285     #error "don't know where the root directory is"
 286 #endif
 287
 288 static void TestDirEnumHelper(wxDir& dir,
 289                               int flags = wxDIR_DEFAULT,
 290                               const wxString& filespec = wxEmptyString)
 291 {
 292     wxString filename;
 293
 294     if ( !dir.IsOpened() )
 295         return;
 296
 297     bool cont = dir.GetFirst(&filename, filespec, flags);
 298     while ( cont )
 299     {
 300         wxPrintf(_T("\t%s\n"), filename.c_str());
 301
 302         cont = dir.GetNext(&filename);
 303     }
 304
 305     wxPuts(_T(""));
 306 }
 307
 308 static void TestDirEnum()
 309 {
 310     wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
 311
 312     wxString cwd = wxGetCwd();
 313     if ( !wxDir::Exists(cwd) )
 314     {
 315         wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
 316         return;
 317     }
 318
 319     wxDir dir(cwd);
 320     if ( !dir.IsOpened() )
 321     {
 322         wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
 323         return;
 324     }
 325
 326     wxPuts(_T("Enumerating everything in current directory:"));
 327     TestDirEnumHelper(dir);
 328
 329     wxPuts(_T("Enumerating really everything in current directory:"));
 330     TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
 331
 332     wxPuts(_T("Enumerating object files in current directory:"));
 333     TestDirEnumHelper(dir, wxDIR_DEFAULT, _T("*.o*"));
 334
 335     wxPuts(_T("Enumerating directories in current directory:"));
 336     TestDirEnumHelper(dir, wxDIR_DIRS);
 337
 338     wxPuts(_T("Enumerating files in current directory:"));
 339     TestDirEnumHelper(dir, wxDIR_FILES);
 340
 341     wxPuts(_T("Enumerating files including hidden in current directory:"));
 342     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 343
 344     dir.Open(ROOTDIR);
 345
 346     wxPuts(_T("Enumerating everything in root directory:"));
 347     TestDirEnumHelper(dir, wxDIR_DEFAULT);
 348
 349     wxPuts(_T("Enumerating directories in root directory:"));
 350     TestDirEnumHelper(dir, wxDIR_DIRS);
 351
 352     wxPuts(_T("Enumerating files in root directory:"));
 353     TestDirEnumHelper(dir, wxDIR_FILES);
 354
 355     wxPuts(_T("Enumerating files including hidden in root directory:"));
 356     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 357
 358     wxPuts(_T("Enumerating files in non existing directory:"));
 359     wxDir dirNo(_T("nosuchdir"));
 360     TestDirEnumHelper(dirNo);
 361 }
 362
 363 class DirPrintTraverser : public wxDirTraverser
 364 {
 365 public:
 366     virtual wxDirTraverseResult OnFile(const wxString& filename)
 367     {
 368         return wxDIR_CONTINUE;
 369     }
 370
 371     virtual wxDirTraverseResult OnDir(const wxString& dirname)
 372     {
 373         wxString path, name, ext;
 374         wxSplitPath(dirname, &path, &name, &ext);
 375
 376         if ( !ext.empty() )
 377             name << _T('.') << ext;
 378
 379         wxString indent;
 380         for ( const wxChar *p = path.c_str(); *p; p++ )
 381         {
 382             if ( wxIsPathSeparator(*p) )
 383                 indent += _T("    ");
 384         }
 385
 386         wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
 387
 388         return wxDIR_CONTINUE;
 389     }
 390 };
 391
 392 static void TestDirTraverse()
 393 {
 394     wxPuts(_T("*** Testing wxDir::Traverse() ***"));
 395
 396     // enum all files
 397     wxArrayString files;
 398     size_t n = wxDir::GetAllFiles(TESTDIR, &files);
 399     wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
 400     if ( n > 1 )
 401     {
 402         wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
 403         wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
 404     }
 405
 406     // enum again with custom traverser
 407     wxPuts(_T("Now enumerating directories:"));
 408     wxDir dir(TESTDIR);
 409     DirPrintTraverser traverser;
 410     dir.Traverse(traverser, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
 411 }
 412
 413 static void TestDirExists()
 414 {
 415     wxPuts(_T("*** Testing wxDir::Exists() ***"));
 416
 417     static const wxChar *dirnames[] =
 418     {
 419         _T("."),
 420 #if defined(__WXMSW__)
 421         _T("c:"),
 422         _T("c:\\"),
 423         _T("\\\\share\\file"),
 424         _T("c:\\dos"),
 425         _T("c:\\dos\\"),
 426         _T("c:\\dos\\\\"),
 427         _T("c:\\autoexec.bat"),
 428 #elif defined(__UNIX__)
 429         _T("/"),
 430         _T("//"),
 431         _T("/usr/bin"),
 432         _T("/usr//bin"),
 433         _T("/usr///bin"),
 434 #endif
 435     };
 436
 437     for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
 438     {
 439         wxPrintf(_T("%-40s: %s\n"),
 440                  dirnames[n],
 441                  wxDir::Exists(dirnames[n]) ? _T("exists")
 442                                             : _T("doesn't exist"));
 443     }
 444 }
 445
 446 #endif // TEST_DIR
 447
 448 // ----------------------------------------------------------------------------
 449 // wxDllLoader
 450 // ----------------------------------------------------------------------------
 451
 452 #ifdef TEST_DLLLOADER
 453
 454 #include "wx/dynlib.h"
 455
 456 static void TestDllLoad()
 457 {
 458 #if defined(__WXMSW__)
 459     static const wxChar *LIB_NAME = _T("kernel32.dll");
 460     static const wxChar *FUNC_NAME = _T("lstrlenA");
 461 #elif defined(__UNIX__)
 462     // weird: using just libc.so does *not* work!
 463     static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
 464     static const wxChar *FUNC_NAME = _T("strlen");
 465 #else
 466     #error "don't know how to test wxDllLoader on this platform"
 467 #endif
 468
 469     wxPuts(_T("*** testing wxDllLoader ***\n"));
 470
 471     wxDynamicLibrary lib(LIB_NAME);
 472     if ( !lib.IsLoaded() )
 473     {
 474         wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
 475     }
 476     else
 477     {
 478         typedef int (*wxStrlenType)(const char *);
 479         wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
 480         if ( !pfnStrlen )
 481         {
 482             wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
 483                      FUNC_NAME, LIB_NAME);
 484         }
 485         else
 486         {
 487             if ( pfnStrlen("foo") != 3 )
 488             {
 489                 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
 490             }
 491             else
 492             {
 493                 wxPuts(_T("... ok"));
 494             }
 495         }
 496     }
 497 }
 498
 499 #endif // TEST_DLLLOADER
 500
 501 // ----------------------------------------------------------------------------
 502 // wxGet/SetEnv
 503 // ----------------------------------------------------------------------------
 504
 505 #ifdef TEST_ENVIRON
 506
 507 #include "wx/utils.h"
 508
 509 static wxString MyGetEnv(const wxString& var)
 510 {
 511     wxString val;
 512     if ( !wxGetEnv(var, &val) )
 513         val = _T("<empty>");
 514     else
 515         val = wxString(_T('\'')) + val + _T('\'');
 516
 517     return val;
 518 }
 519
 520 static void TestEnvironment()
 521 {
 522     const wxChar *var = _T("wxTestVar");
 523
 524     wxPuts(_T("*** testing environment access functions ***"));
 525
 526     wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
 527     wxSetEnv(var, _T("value for wxTestVar"));
 528     wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 529     wxSetEnv(var, _T("another value"));
 530     wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 531     wxUnsetEnv(var);
 532     wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 533     wxPrintf(_T("PATH = %s\n"),  MyGetEnv(_T("PATH")).c_str());
 534 }
 535
 536 #endif // TEST_ENVIRON
 537
 538 // ----------------------------------------------------------------------------
 539 // wxExecute
 540 // ----------------------------------------------------------------------------
 541
 542 #ifdef TEST_EXECUTE
 543
 544 #include "wx/utils.h"
 545
 546 static void TestExecute()
 547 {
 548     wxPuts(_T("*** testing wxExecute ***"));
 549
 550 #ifdef __UNIX__
 551     #define COMMAND "cat -n ../../Makefile" // "echo hi"
 552     #define SHELL_COMMAND "echo hi from shell"
 553     #define REDIRECT_COMMAND COMMAND // "date"
 554 #elif defined(__WXMSW__)
 555     #define COMMAND "command.com /c echo hi"
 556     #define SHELL_COMMAND "echo hi"
 557     #define REDIRECT_COMMAND COMMAND
 558 #else
 559     #error "no command to exec"
 560 #endif // OS
 561
 562     wxPrintf(_T("Testing wxShell: "));
 563     fflush(stdout);
 564     if ( wxShell(_T(SHELL_COMMAND)) )
 565         wxPuts(_T("Ok."));
 566     else
 567         wxPuts(_T("ERROR."));
 568
 569     wxPrintf(_T("Testing wxExecute: "));
 570     fflush(stdout);
 571     if ( wxExecute(_T(COMMAND), true /* sync */) == 0 )
 572         wxPuts(_T("Ok."));
 573     else
 574         wxPuts(_T("ERROR."));
 575
 576 #if 0 // no, it doesn't work (yet?)
 577     wxPrintf(_T("Testing async wxExecute: "));
 578     fflush(stdout);
 579     if ( wxExecute(COMMAND) != 0 )
 580         wxPuts(_T("Ok (command launched)."));
 581     else
 582         wxPuts(_T("ERROR."));
 583 #endif // 0
 584
 585     wxPrintf(_T("Testing wxExecute with redirection:\n"));
 586     wxArrayString output;
 587     if ( wxExecute(_T(REDIRECT_COMMAND), output) != 0 )
 588     {
 589         wxPuts(_T("ERROR."));
 590     }
 591     else
 592     {
 593         size_t count = output.GetCount();
 594         for ( size_t n = 0; n < count; n++ )
 595         {
 596             wxPrintf(_T("\t%s\n"), output[n].c_str());
 597         }
 598
 599         wxPuts(_T("Ok."));
 600     }
 601 }
 602
 603 #endif // TEST_EXECUTE
 604
 605 // ----------------------------------------------------------------------------
 606 // file
 607 // ----------------------------------------------------------------------------
 608
 609 #ifdef TEST_FILE
 610
 611 #include "wx/file.h"
 612 #include "wx/ffile.h"
 613 #include "wx/textfile.h"
 614
 615 static void TestFileRead()
 616 {
 617     wxPuts(_T("*** wxFile read test ***"));
 618
 619     wxFile file(_T("testdata.fc"));
 620     if ( file.IsOpened() )
 621     {
 622         wxPrintf(_T("File length: %lu\n"), file.Length());
 623
 624         wxPuts(_T("File dump:\n----------"));
 625
 626         static const off_t len = 1024;
 627         wxChar buf[len];
 628         for ( ;; )
 629         {
 630             off_t nRead = file.Read(buf, len);
 631             if ( nRead == wxInvalidOffset )
 632             {
 633                 wxPrintf(_T("Failed to read the file."));
 634                 break;
 635             }
 636
 637             fwrite(buf, nRead, 1, stdout);
 638
 639             if ( nRead < len )
 640                 break;
 641         }
 642
 643         wxPuts(_T("----------"));
 644     }
 645     else
 646     {
 647         wxPrintf(_T("ERROR: can't open test file.\n"));
 648     }
 649
 650     wxPuts(_T(""));
 651 }
 652
 653 static void TestTextFileRead()
 654 {
 655     wxPuts(_T("*** wxTextFile read test ***"));
 656
 657     wxTextFile file(_T("testdata.fc"));
 658     if ( file.Open() )
 659     {
 660         wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
 661         wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
 662
 663         wxString s;
 664
 665         wxPuts(_T("\nDumping the entire file:"));
 666         for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
 667         {
 668             wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 669         }
 670         wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 671
 672         wxPuts(_T("\nAnd now backwards:"));
 673         for ( s = file.GetLastLine();
 674               file.GetCurrentLine() != 0;
 675               s = file.GetPrevLine() )
 676         {
 677             wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 678         }
 679         wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 680     }
 681     else
 682     {
 683         wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
 684     }
 685
 686     wxPuts(_T(""));
 687 }
 688
 689 static void TestFileCopy()
 690 {
 691     wxPuts(_T("*** Testing wxCopyFile ***"));
 692
 693     static const wxChar *filename1 = _T("testdata.fc");
 694     static const wxChar *filename2 = _T("test2");
 695     if ( !wxCopyFile(filename1, filename2) )
 696     {
 697         wxPuts(_T("ERROR: failed to copy file"));
 698     }
 699     else
 700     {
 701         wxFFile f1(filename1, _T("rb")),
 702                 f2(filename2, _T("rb"));
 703
 704         if ( !f1.IsOpened() || !f2.IsOpened() )
 705         {
 706             wxPuts(_T("ERROR: failed to open file(s)"));
 707         }
 708         else
 709         {
 710             wxString s1, s2;
 711             if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
 712             {
 713                 wxPuts(_T("ERROR: failed to read file(s)"));
 714             }
 715             else
 716             {
 717                 if ( (s1.length() != s2.length()) ||
 718                      (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
 719                 {
 720                     wxPuts(_T("ERROR: copy error!"));
 721                 }
 722                 else
 723                 {
 724                     wxPuts(_T("File was copied ok."));
 725                 }
 726             }
 727         }
 728     }
 729
 730     if ( !wxRemoveFile(filename2) )
 731     {
 732         wxPuts(_T("ERROR: failed to remove the file"));
 733     }
 734
 735     wxPuts(_T(""));
 736 }
 737
 738 #endif // TEST_FILE
 739
 740 // ----------------------------------------------------------------------------
 741 // wxFileConfig
 742 // ----------------------------------------------------------------------------
 743
 744 #ifdef TEST_FILECONF
 745
 746 #include "wx/confbase.h"
 747 #include "wx/fileconf.h"
 748
 749 static const struct FileConfTestData
 750 {
 751     const wxChar *name;      // value name
 752     const wxChar *value;     // the value from the file
 753 } fcTestData[] =
 754 {
 755     { _T("value1"),                       _T("one") },
 756     { _T("value2"),                       _T("two") },
 757     { _T("novalue"),                      _T("default") },
 758 };
 759
 760 static void TestFileConfRead()
 761 {
 762     wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
 763
 764     wxFileConfig fileconf(_T("test"), wxEmptyString,
 765                           _T("testdata.fc"), wxEmptyString,
 766                           wxCONFIG_USE_RELATIVE_PATH);
 767
 768     // test simple reading
 769     wxPuts(_T("\nReading config file:"));
 770     wxString defValue(_T("default")), value;
 771     for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
 772     {
 773         const FileConfTestData& data = fcTestData[n];
 774         value = fileconf.Read(data.name, defValue);
 775         wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
 776         if ( value == data.value )
 777         {
 778             wxPuts(_T("(ok)"));
 779         }
 780         else
 781         {
 782             wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
 783         }
 784     }
 785
 786     // test enumerating the entries
 787     wxPuts(_T("\nEnumerating all root entries:"));
 788     long dummy;
 789     wxString name;
 790     bool cont = fileconf.GetFirstEntry(name, dummy);
 791     while ( cont )
 792     {
 793         wxPrintf(_T("\t%s = %s\n"),
 794                name.c_str(),
 795                fileconf.Read(name.c_str(), _T("ERROR")).c_str());
 796
 797         cont = fileconf.GetNextEntry(name, dummy);
 798     }
 799
 800     static const wxChar *testEntry = _T("TestEntry");
 801     wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
 802     fileconf.Write(testEntry, _T("A value"));
 803     fileconf.DeleteEntry(testEntry);
 804     wxPrintf(fileconf.HasEntry(testEntry) ? _T("ERROR\n") : _T("ok\n"));
 805 }
 806
 807 #endif // TEST_FILECONF
 808
 809 // ----------------------------------------------------------------------------
 810 // wxFileName
 811 // ----------------------------------------------------------------------------
 812
 813 #ifdef TEST_FILENAME
 814
 815 #include "wx/filename.h"
 816
 817 static void DumpFileName(const wxFileName& fn)
 818 {
 819     wxString full = fn.GetFullPath();
 820
 821     wxString vol, path, name, ext;
 822     wxFileName::SplitPath(full, &vol, &path, &name, &ext);
 823
 824     wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
 825              full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
 826
 827     wxFileName::SplitPath(full, &path, &name, &ext);
 828     wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
 829              path.c_str(), name.c_str(), ext.c_str());
 830
 831     wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
 832     wxPrintf(_T("with volume: \t'%s'\n"),
 833              fn.GetPath(wxPATH_GET_VOLUME).c_str());
 834     wxPrintf(_T("with separator:\t'%s'\n"),
 835              fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
 836     wxPrintf(_T("with both:   \t'%s'\n"),
 837              fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
 838
 839     wxPuts(_T("The directories in the path are:"));
 840     wxArrayString dirs = fn.GetDirs();
 841     size_t count = dirs.GetCount();
 842     for ( size_t n = 0; n < count; n++ )
 843     {
 844         wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
 845     }
 846 }
 847
 848 static struct FileNameInfo
 849 {
 850     const wxChar *fullname;
 851     const wxChar *volume;
 852     const wxChar *path;
 853     const wxChar *name;
 854     const wxChar *ext;
 855     bool isAbsolute;
 856     wxPathFormat format;
 857 } filenames[] =
 858 {
 859     // Unix file names
 860     { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), true, wxPATH_UNIX },
 861     { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), true, wxPATH_UNIX },
 862     { _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), true, wxPATH_UNIX },
 863     { _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), false, wxPATH_UNIX },
 864     { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_UNIX },
 865     { _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), true, wxPATH_UNIX },
 866     { _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), true, wxPATH_UNIX },
 867     { _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), false, wxPATH_UNIX },
 868     { _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), true, wxPATH_UNIX },
 869
 870     // Windows file names
 871     { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
 872     { _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), false, wxPATH_DOS },
 873     { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
 874     { _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
 875     { _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), true, wxPATH_DOS },
 876     { _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
 877     { _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), true, wxPATH_DOS },
 878
 879     // wxFileName support for Mac file names is broken currently
 880 #if 0
 881     // Mac file names
 882     { _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), true, wxPATH_MAC },
 883     { _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), true, wxPATH_MAC },
 884     { _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), true, wxPATH_MAC },
 885     { _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), false, wxPATH_MAC },
 886     { _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
 887     { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
 888 #endif // 0
 889
 890     // VMS file names
 891     { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), true, wxPATH_VMS },
 892     { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
 893 };
 894
 895 static void TestFileNameConstruction()
 896 {
 897     wxPuts(_T("*** testing wxFileName construction ***"));
 898
 899     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
 900     {
 901         const FileNameInfo& fni = filenames[n];
 902
 903         wxFileName fn(fni.fullname, fni.format);
 904
 905         wxString fullname = fn.GetFullPath(fni.format);
 906         if ( fullname != fni.fullname )
 907         {
 908             wxPrintf(_T("ERROR: fullname should be '%s'\n"), fni.fullname);
 909         }
 910
 911         bool isAbsolute = fn.IsAbsolute(fni.format);
 912         wxPrintf(_T("'%s' is %s (%s)\n\t"),
 913                fullname.c_str(),
 914                isAbsolute ? "absolute" : "relative",
 915                isAbsolute == fni.isAbsolute ? "ok" : "ERROR");
 916
 917         if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), fni.format) )
 918         {
 919             wxPuts(_T("ERROR (couldn't be normalized)"));
 920         }
 921         else
 922         {
 923             wxPrintf(_T("normalized: '%s'\n"), fn.GetFullPath(fni.format).c_str());
 924         }
 925     }
 926
 927     wxPuts(_T(""));
 928 }
 929
 930 static void TestFileNameSplit()
 931 {
 932     wxPuts(_T("*** testing wxFileName splitting ***"));
 933
 934     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
 935     {
 936         const FileNameInfo& fni = filenames[n];
 937         wxString volume, path, name, ext;
 938         wxFileName::SplitPath(fni.fullname,
 939                               &volume, &path, &name, &ext, fni.format);
 940
 941         wxPrintf(_T("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'"),
 942                fni.fullname,
 943                volume.c_str(), path.c_str(), name.c_str(), ext.c_str());
 944
 945         if ( volume != fni.volume )
 946             wxPrintf(_T(" (ERROR: volume = '%s')"), fni.volume);
 947         if ( path != fni.path )
 948             wxPrintf(_T(" (ERROR: path = '%s')"), fni.path);
 949         if ( name != fni.name )
 950             wxPrintf(_T(" (ERROR: name = '%s')"), fni.name);
 951         if ( ext != fni.ext )
 952             wxPrintf(_T(" (ERROR: ext = '%s')"), fni.ext);
 953
 954         wxPuts(_T(""));
 955     }
 956 }
 957
 958 static void TestFileNameTemp()
 959 {
 960     wxPuts(_T("*** testing wxFileName temp file creation ***"));
 961
 962     static const wxChar *tmpprefixes[] =
 963     {
 964         _T(""),
 965         _T("foo"),
 966         _T(".."),
 967         _T("../bar"),
 968 #ifdef __UNIX__
 969         _T("/tmp/foo"),
 970         _T("/tmp/foo/bar"), // this one must be an error
 971 #endif // __UNIX__
 972     };
 973
 974     for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
 975     {
 976         wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
 977         if ( path.empty() )
 978         {
 979             // "error" is not in upper case because it may be ok
 980             wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
 981         }
 982         else
 983         {
 984             wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
 985                    tmpprefixes[n], path.c_str());
 986
 987             if ( !wxRemoveFile(path) )
 988             {
 989                 wxLogWarning(_T("Failed to remove temp file '%s'"),
 990                              path.c_str());
 991             }
 992         }
 993     }
 994 }
 995
 996 static void TestFileNameMakeRelative()
 997 {
 998     wxPuts(_T("*** testing wxFileName::MakeRelativeTo() ***"));
 999
1000     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1001     {
1002         const FileNameInfo& fni = filenames[n];
1003
1004         wxFileName fn(fni.fullname, fni.format);
1005
1006         // choose the base dir of the same format
1007         wxString base;
1008         switch ( fni.format )
1009         {
1010             case wxPATH_UNIX:
1011                 base = _T("/usr/bin/");
1012                 break;
1013
1014             case wxPATH_DOS:
1015                 base = _T("c:\\");
1016                 break;
1017
1018             case wxPATH_MAC:
1019             case wxPATH_VMS:
1020                 // TODO: I don't know how this is supposed to work there
1021                 continue;
1022
1023             case wxPATH_NATIVE: // make gcc happy
1024             default:
1025                 wxFAIL_MSG( _T("unexpected path format") );
1026         }
1027
1028         wxPrintf(_T("'%s' relative to '%s': "),
1029                fn.GetFullPath(fni.format).c_str(), base.c_str());
1030
1031         if ( !fn.MakeRelativeTo(base, fni.format) )
1032         {
1033             wxPuts(_T("unchanged"));
1034         }
1035         else
1036         {
1037             wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
1038         }
1039     }
1040 }
1041
1042 static void TestFileNameMakeAbsolute()
1043 {
1044     wxPuts(_T("*** testing wxFileName::MakeAbsolute() ***"));
1045
1046     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1047     {
1048         const FileNameInfo& fni = filenames[n];
1049         wxFileName fn(fni.fullname, fni.format);
1050
1051         wxPrintf(_T("'%s' absolutized: "),
1052                fn.GetFullPath(fni.format).c_str());
1053         fn.MakeAbsolute();
1054         wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
1055     }
1056
1057     wxPuts(_T(""));
1058 }
1059
1060 static void TestFileNameComparison()
1061 {
1062     // TODO!
1063 }
1064
1065 static void TestFileNameOperations()
1066 {
1067     // TODO!
1068 }
1069
1070 static void TestFileNameCwd()
1071 {
1072     // TODO!
1073 }
1074
1075 #endif // TEST_FILENAME
1076
1077 // ----------------------------------------------------------------------------
1078 // wxFileName time functions
1079 // ----------------------------------------------------------------------------
1080
1081 #ifdef TEST_FILETIME
1082
1083 #include <wx/filename.h>
1084 #include <wx/datetime.h>
1085
1086 static void TestFileGetTimes()
1087 {
1088     wxFileName fn(_T("testdata.fc"));
1089
1090     wxDateTime dtAccess, dtMod, dtCreate;
1091     if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
1092     {
1093         wxPrintf(_T("ERROR: GetTimes() failed.\n"));
1094     }
1095     else
1096     {
1097         static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
1098
1099         wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
1100         wxPrintf(_T("Creation:    \t%s\n"), dtCreate.Format(fmt).c_str());
1101         wxPrintf(_T("Last read:   \t%s\n"), dtAccess.Format(fmt).c_str());
1102         wxPrintf(_T("Last write:  \t%s\n"), dtMod.Format(fmt).c_str());
1103     }
1104 }
1105
1106 static void TestFileSetTimes()
1107 {
1108     wxFileName fn(_T("testdata.fc"));
1109
1110     if ( !fn.Touch() )
1111     {
1112         wxPrintf(_T("ERROR: Touch() failed.\n"));
1113     }
1114 }
1115
1116 #endif // TEST_FILETIME
1117
1118 // ----------------------------------------------------------------------------
1119 // wxHashTable
1120 // ----------------------------------------------------------------------------
1121
1122 #ifdef TEST_HASH
1123
1124 #include "wx/hash.h"
1125
1126 struct Foo
1127 {
1128     Foo(int n_) { n = n_; count++; }
1129     ~Foo() { count--; }
1130
1131     int n;
1132
1133     static size_t count;
1134 };
1135
1136 size_t Foo::count = 0;
1137
1138 WX_DECLARE_LIST(Foo, wxListFoos);
1139 WX_DECLARE_HASH(Foo, wxListFoos, wxHashFoos);
1140
1141 #include "wx/listimpl.cpp"
1142
1143 WX_DEFINE_LIST(wxListFoos);
1144
1145 static void TestHash()
1146 {
1147     wxPuts(_T("*** Testing wxHashTable ***\n"));
1148
1149     {
1150         wxHashTable hash(wxKEY_INTEGER, 10), hash2(wxKEY_STRING);
1151         wxObject o;
1152         int i;
1153
1154         for ( i = 0; i < 100; ++i )
1155             hash.Put(i, &o + i);
1156
1157         hash.BeginFind();
1158         wxHashTable::compatibility_iterator it = hash.Next();
1159         i = 0;
1160
1161         while (it)
1162         {
1163             ++i;
1164             it = hash.Next();
1165         }
1166
1167         if (i != 100)
1168             wxPuts(_T("Error in wxHashTable::compatibility_iterator\n"));
1169
1170         for ( i = 99; i >= 0; --i )
1171             if( hash.Get(i) != &o + i )
1172                 wxPuts(_T("Error in wxHashTable::Get/Put\n"));
1173
1174         for ( i = 0; i < 100; ++i )
1175             hash.Put(i, &o + i + 20);
1176
1177         for ( i = 99; i >= 0; --i )
1178             if( hash.Get(i) != &o + i)
1179                 wxPuts(_T("Error (2) in wxHashTable::Get/Put\n"));
1180
1181         for ( i = 0; i < 50; ++i )
1182             if( hash.Delete(i) != &o + i)
1183                 wxPuts(_T("Error in wxHashTable::Delete\n"));
1184
1185         for ( i = 50; i < 100; ++i )
1186             if( hash.Get(i) != &o + i)
1187                 wxPuts(_T("Error (3) in wxHashTable::Get/Put\n"));
1188
1189         for ( i = 0; i < 50; ++i )
1190             if( hash.Get(i) != &o + i + 20)
1191                 wxPuts(_T("Error (4) in wxHashTable::Put/Delete\n"));
1192
1193         for ( i = 0; i < 50; ++i )
1194             if( hash.Delete(i) != &o + i + 20)
1195                 wxPuts(_T("Error (2) in wxHashTable::Delete\n"));
1196
1197         for ( i = 0; i < 50; ++i )
1198             if( hash.Get(i) != NULL)
1199                 wxPuts(_T("Error (5) in wxHashTable::Put/Delete\n"));
1200
1201         hash2.Put(_T("foo"), &o + 1);
1202         hash2.Put(_T("bar"), &o + 2);
1203         hash2.Put(_T("baz"), &o + 3);
1204
1205         if (hash2.Get(_T("moo")) != NULL)
1206             wxPuts(_T("Error in wxHashTable::Get\n"));
1207
1208         if (hash2.Get(_T("bar")) != &o + 2)
1209             wxPuts(_T("Error in wxHashTable::Get/Put\n"));
1210
1211         hash2.Put(_T("bar"), &o + 0);
1212
1213         if (hash2.Get(_T("bar")) != &o + 2)
1214             wxPuts(_T("Error (2) in wxHashTable::Get/Put\n"));
1215     }
1216 #if !wxUSE_STL
1217     {
1218         wxHashFoos hash;
1219         hash.DeleteContents(true);
1220
1221         wxPrintf(_T("Hash created: %u foos in hash, %u foos totally\n"),
1222                hash.GetCount(), Foo::count);
1223
1224         static const int hashTestData[] =
1225         {
1226             0, 1, 17, -2, 2, 4, -4, 345, 3, 3, 2, 1,
1227         };
1228
1229         size_t n;
1230         for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
1231         {
1232             hash.Put(hashTestData[n], n, new Foo(n));
1233         }
1234
1235         wxPrintf(_T("Hash filled: %u foos in hash, %u foos totally\n"),
1236                hash.GetCount(), Foo::count);
1237
1238         wxPuts(_T("Hash access test:"));
1239         for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
1240         {
1241             wxPrintf(_T("\tGetting element with key %d, value %d: "),
1242                    hashTestData[n], n);
1243             Foo *foo = hash.Get(hashTestData[n], n);
1244             if ( !foo )
1245             {
1246                 wxPrintf(_T("ERROR, not found.\n"));
1247             }
1248             else
1249             {
1250                 wxPrintf(_T("%d (%s)\n"), foo->n,
1251                        (size_t)foo->n == n ? "ok" : "ERROR");
1252             }
1253         }
1254
1255         wxPrintf(_T("\nTrying to get an element not in hash: "));
1256
1257         if ( hash.Get(1234) || hash.Get(1, 0) )
1258         {
1259             wxPuts(_T("ERROR: found!"));
1260         }
1261         else
1262         {
1263             wxPuts(_T("ok (not found)"));
1264         }
1265     }
1266 #endif
1267
1268     wxPrintf(_T("Hash destroyed: %u foos left\n"), Foo::count);
1269     wxPuts(_T("*** Testing wxHashTable finished ***\n"));
1270 }
1271
1272 #endif // TEST_HASH
1273
1274 // ----------------------------------------------------------------------------
1275 // wxHashMap
1276 // ----------------------------------------------------------------------------
1277
1278 #ifdef TEST_HASHMAP
1279
1280 #include "wx/hashmap.h"
1281
1282 // test compilation of basic map types
1283 WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash, wxPointerEqual, myPtrHashMap );
1284 WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
1285 WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
1286                      myUnsignedHashMap );
1287 WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
1288                      myTestHashMap1 );
1289 WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
1290                      myTestHashMap2 );
1291 WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
1292                      myTestHashMap3 );
1293 WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
1294                      myTestHashMap4 );
1295
1296 // same as:
1297 // WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
1298 //                      myStringHashMap );
1299 WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
1300
1301 typedef myStringHashMap::iterator Itor;
1302
1303 static void TestHashMap()
1304 {
1305     wxPuts(_T("*** Testing wxHashMap ***\n"));
1306     myStringHashMap sh(0); // as small as possible
1307     wxString buf;
1308     size_t i;
1309     const size_t count = 10000;
1310
1311     // init with some data
1312     for( i = 0; i < count; ++i )
1313     {
1314         buf.Printf(wxT("%d"), i );
1315         sh[buf] = wxT("A") + buf + wxT("C");
1316     }
1317
1318     // test that insertion worked
1319     if( sh.size() != count )
1320     {
1321         wxPrintf(_T("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n"), sh.size(), count);
1322     }
1323
1324     for( i = 0; i < count; ++i )
1325     {
1326         buf.Printf(wxT("%d"), i );
1327         if( sh[buf] != wxT("A") + buf + wxT("C") )
1328         {
1329             wxPrintf(_T("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n"));
1330             return;
1331         }
1332     }
1333
1334     // check that iterators work
1335     Itor it;
1336     for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1337     {
1338         if( i == count )
1339         {
1340             wxPrintf(_T("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n"));
1341             return;
1342         }
1343
1344         if( it->second != sh[it->first] )
1345         {
1346             wxPrintf(_T("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n"));
1347             return;
1348         }
1349     }
1350
1351     if( sh.size() != i )
1352     {
1353         wxPrintf(_T("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n"), i, count);
1354     }
1355
1356     // test copy ctor, assignment operator
1357     myStringHashMap h1( sh ), h2( 0 );
1358     h2 = sh;
1359
1360     for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1361     {
1362         if( h1[it->first] != it->second )
1363         {
1364             wxPrintf(_T("*** ERROR: COPY CTOR BROKEN %s ***\n"), it->first.c_str());
1365         }
1366
1367         if( h2[it->first] != it->second )
1368         {
1369             wxPrintf(_T("*** ERROR: OPERATOR= BROKEN %s ***\n"), it->first.c_str());
1370         }
1371     }
1372
1373     // other tests
1374     for( i = 0; i < count; ++i )
1375     {
1376         buf.Printf(wxT("%d"), i );
1377         size_t sz = sh.size();
1378
1379         // test find() and erase(it)
1380         if( i < 100 )
1381         {
1382             it = sh.find( buf );
1383             if( it != sh.end() )
1384             {
1385                 sh.erase( it );
1386
1387                 if( sh.find( buf ) != sh.end() )
1388                 {
1389                     wxPrintf(_T("*** ERROR: FOUND DELETED ELEMENT %u ***\n"), i);
1390                 }
1391             }
1392             else
1393                 wxPrintf(_T("*** ERROR: CANT FIND ELEMENT %u ***\n"), i);
1394         }
1395         else
1396         // test erase(key)
1397         {
1398             size_t c = sh.erase( buf );
1399             if( c != 1 )
1400                 wxPrintf(_T("*** ERROR: SHOULD RETURN 1 ***\n"));
1401
1402             if( sh.find( buf ) != sh.end() )
1403             {
1404                 wxPrintf(_T("*** ERROR: FOUND DELETED ELEMENT %u ***\n"), i);
1405             }
1406         }
1407
1408         // count should decrease
1409         if( sh.size() != sz - 1 )
1410         {
1411             wxPrintf(_T("*** ERROR: COUNT DID NOT DECREASE ***\n"));
1412         }
1413     }
1414
1415     wxPrintf(_T("*** Finished testing wxHashMap ***\n"));
1416 }
1417
1418 #endif // TEST_HASHMAP
1419
1420 // ----------------------------------------------------------------------------
1421 // wxHashSet
1422 // ----------------------------------------------------------------------------
1423
1424 #ifdef TEST_HASHSET
1425
1426 #include "wx/hashset.h"
1427
1428 // test compilation of basic map types
1429 WX_DECLARE_HASH_SET( int*, wxPointerHash, wxPointerEqual, myPtrHashSet );
1430 WX_DECLARE_HASH_SET( long, wxIntegerHash, wxIntegerEqual, myLongHashSet );
1431 WX_DECLARE_HASH_SET( unsigned long, wxIntegerHash, wxIntegerEqual,
1432                      myUnsignedHashSet );
1433 WX_DECLARE_HASH_SET( unsigned int, wxIntegerHash, wxIntegerEqual,
1434                      myTestHashSet1 );
1435 WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual,
1436                      myTestHashSet2 );
1437 WX_DECLARE_HASH_SET( short, wxIntegerHash, wxIntegerEqual,
1438                      myTestHashSet3 );
1439 WX_DECLARE_HASH_SET( unsigned short, wxIntegerHash, wxIntegerEqual,
1440                      myTestHashSet4 );
1441 WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual,
1442                      myTestHashSet5 );
1443
1444 struct MyStruct
1445 {
1446     int* ptr;
1447     wxString str;
1448 };
1449
1450 class MyHash
1451 {
1452 public:
1453     unsigned long operator()(const MyStruct& s) const
1454         { return m_dummy(s.ptr); }
1455     MyHash& operator=(const MyHash&) { return *this; }
1456 private:
1457     wxPointerHash m_dummy;
1458 };
1459
1460 class MyEqual
1461 {
1462 public:
1463     bool operator()(const MyStruct& s1, const MyStruct& s2) const
1464         { return s1.ptr == s2.ptr; }
1465     MyEqual& operator=(const MyEqual&) { return *this; }
1466 };
1467
1468 WX_DECLARE_HASH_SET( MyStruct, MyHash, MyEqual, mySet );
1469
1470 typedef myTestHashSet5 wxStringHashSet;
1471
1472 static void TestHashSet()
1473 {
1474     wxPrintf(_T("*** Testing wxHashSet ***\n"));
1475
1476     wxStringHashSet set1;
1477
1478     set1.insert( _T("abc") );
1479     set1.insert( _T("bbc") );
1480     set1.insert( _T("cbc") );
1481     set1.insert( _T("abc") );
1482
1483     if( set1.size() != 3 )
1484         wxPrintf(_T("*** ERROR IN INSERT ***\n"));
1485
1486     mySet set2;
1487     int dummy;
1488     MyStruct tmp;
1489
1490     tmp.ptr = &dummy; tmp.str = _T("ABC");
1491     set2.insert( tmp );
1492     tmp.ptr = &dummy + 1;
1493     set2.insert( tmp );
1494     tmp.ptr = &dummy; tmp.str = _T("CDE");
1495     set2.insert( tmp );
1496
1497     if( set2.size() != 2 )
1498         wxPrintf(_T("*** ERROR IN INSERT - 2 ***\n"));
1499
1500     mySet::iterator it = set2.find( tmp );
1501
1502     if( it == set2.end() )
1503         wxPrintf(_T("*** ERROR IN FIND - 1 ***\n"));
1504     if( it->ptr != &dummy )
1505         wxPrintf(_T("*** ERROR IN FIND - 2 ***\n"));
1506     if( it->str != _T("ABC") )
1507         wxPrintf(_T("*** ERROR IN INSERT - 3 ***\n"));
1508
1509     wxPrintf(_T("*** Finished testing wxHashSet ***\n"));
1510 }
1511
1512 #endif // TEST_HASHSET
1513
1514 // ----------------------------------------------------------------------------
1515 // wxList
1516 // ----------------------------------------------------------------------------
1517
1518 #ifdef TEST_LIST
1519
1520 #include "wx/list.h"
1521
1522 WX_DECLARE_LIST(Bar, wxListBars);
1523 #include "wx/listimpl.cpp"
1524 WX_DEFINE_LIST(wxListBars);
1525
1526 WX_DECLARE_LIST(int, wxListInt);
1527 WX_DEFINE_LIST(wxListInt);
1528
1529 static void TestList()
1530 {
1531     wxPuts(_T("*** Testing wxList operations ***\n"));
1532     {
1533         wxListInt list1;
1534         int dummy[5];
1535         int i;
1536
1537         for ( i = 0; i < 5; ++i )
1538             list1.Append(dummy + i);
1539
1540         if ( list1.GetCount() != 5 )
1541             wxPuts(_T("Wrong number of items in list\n"));
1542
1543         if ( list1.Item(3)->GetData() != dummy + 3 )
1544             wxPuts(_T("Error in Item()\n"));
1545
1546         if ( !list1.Find(dummy + 4) )
1547             wxPuts(_T("Error in Find()\n"));
1548
1549         wxListInt::compatibility_iterator node = list1.GetFirst();
1550         i = 0;
1551
1552         while (node)
1553         {
1554             if ( node->GetData() != dummy + i )
1555                 wxPuts(_T("Error in compatibility_iterator\n"));
1556             node = node->GetNext();
1557             ++i;
1558         }
1559
1560         if ( size_t(i) != list1.GetCount() )
1561             wxPuts(_T("Error in compatibility_iterator\n"));
1562
1563         list1.Insert(dummy + 0);
1564         list1.Insert(1, dummy + 1);
1565         list1.Insert(list1.GetFirst()->GetNext()->GetNext(), dummy + 2);
1566
1567         node = list1.GetFirst();
1568         i = 0;
1569
1570         while (i < 3)
1571         {
1572             int* t = node->GetData();
1573             if ( t != dummy + i )
1574                 wxPuts(_T("Error in Insert\n"));
1575             node = node->GetNext();
1576             ++i;
1577         }
1578     }
1579
1580     wxPuts(_T("*** Testing wxList operations finished ***\n"));
1581
1582     wxPuts(_T("*** Testing std::list operations ***\n"));
1583
1584     {
1585         wxListInt list1;
1586         wxListInt::iterator it, en;
1587         wxListInt::reverse_iterator rit, ren;
1588         int i;
1589         for ( i = 0; i < 5; ++i )
1590             list1.push_back(i + &i);
1591
1592         for ( it = list1.begin(), en = list1.end(), i = 0;
1593               it != en; ++it, ++i )
1594             if ( *it != i + &i )
1595                 wxPuts(_T("Error in iterator\n"));
1596
1597         for ( rit = list1.rbegin(), ren = list1.rend(), i = 4;
1598               rit != ren; ++rit, --i )
1599             if ( *rit != i + &i )
1600                 wxPuts(_T("Error in reverse_iterator\n"));
1601
1602         if ( *list1.rbegin() != *--list1.end() ||
1603              *list1.begin() != *--list1.rend() )
1604             wxPuts(_T("Error in iterator/reverse_iterator\n"));
1605         if ( *list1.begin() != *--++list1.begin() ||
1606              *list1.rbegin() != *--++list1.rbegin() )
1607             wxPuts(_T("Error in iterator/reverse_iterator\n"));
1608
1609         if ( list1.front() != &i || list1.back() != &i + 4 )
1610             wxPuts(_T("Error in front()/back()\n"));
1611
1612         list1.erase(list1.begin());
1613         list1.erase(--list1.end());
1614
1615         for ( it = list1.begin(), en = list1.end(), i = 1;
1616               it != en; ++it, ++i )
1617             if ( *it != i + &i )
1618                 wxPuts(_T("Error in erase()\n"));
1619     }
1620
1621     wxPuts(_T("*** Testing std::list operations finished ***\n"));
1622 }
1623
1624 static void TestListCtor()
1625 {
1626     wxPuts(_T("*** Testing wxList construction ***\n"));
1627
1628     {
1629         wxListBars list1;
1630         list1.Append(new Bar(_T("first")));
1631         list1.Append(new Bar(_T("second")));
1632
1633         wxPrintf(_T("After 1st list creation: %u objects in the list, %u objects total.\n"),
1634                list1.GetCount(), Bar::GetNumber());
1635
1636         wxListBars list2;
1637         list2 = list1;
1638
1639         wxPrintf(_T("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n"),
1640                list1.GetCount(), list2.GetCount(), Bar::GetNumber());
1641
1642 #if !wxUSE_STL
1643         list1.DeleteContents(true);
1644 #else
1645         WX_CLEAR_LIST(wxListBars, list1);
1646 #endif
1647     }
1648
1649     wxPrintf(_T("After list destruction: %u objects left.\n"), Bar::GetNumber());
1650 }
1651
1652 #endif // TEST_LIST
1653
1654 // ----------------------------------------------------------------------------
1655 // wxLocale
1656 // ----------------------------------------------------------------------------
1657
1658 #ifdef TEST_LOCALE
1659
1660 #include "wx/intl.h"
1661 #include "wx/utils.h"   // for wxSetEnv
1662
1663 static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
1664
1665 // find the name of the language from its value
1666 static const wxChar *GetLangName(int lang)
1667 {
1668     static const wxChar *languageNames[] =
1669     {
1670         _T("DEFAULT"),
1671         _T("UNKNOWN"),
1672         _T("ABKHAZIAN"),
1673         _T("AFAR"),
1674         _T("AFRIKAANS"),
1675         _T("ALBANIAN"),
1676         _T("AMHARIC"),
1677         _T("ARABIC"),
1678         _T("ARABIC_ALGERIA"),
1679         _T("ARABIC_BAHRAIN"),
1680         _T("ARABIC_EGYPT"),
1681         _T("ARABIC_IRAQ"),
1682         _T("ARABIC_JORDAN"),
1683         _T("ARABIC_KUWAIT"),
1684         _T("ARABIC_LEBANON"),
1685         _T("ARABIC_LIBYA"),
1686         _T("ARABIC_MOROCCO"),
1687         _T("ARABIC_OMAN"),
1688         _T("ARABIC_QATAR"),
1689         _T("ARABIC_SAUDI_ARABIA"),
1690         _T("ARABIC_SUDAN"),
1691         _T("ARABIC_SYRIA"),
1692         _T("ARABIC_TUNISIA"),
1693         _T("ARABIC_UAE"),
1694         _T("ARABIC_YEMEN"),
1695         _T("ARMENIAN"),
1696         _T("ASSAMESE"),
1697         _T("AYMARA"),
1698         _T("AZERI"),
1699         _T("AZERI_CYRILLIC"),
1700         _T("AZERI_LATIN"),
1701         _T("BASHKIR"),
1702         _T("BASQUE"),
1703         _T("BELARUSIAN"),
1704         _T("BENGALI"),
1705         _T("BHUTANI"),
1706         _T("BIHARI"),
1707         _T("BISLAMA"),
1708         _T("BRETON"),
1709         _T("BULGARIAN"),
1710         _T("BURMESE"),
1711         _T("CAMBODIAN"),
1712         _T("CATALAN"),
1713         _T("CHINESE"),
1714         _T("CHINESE_SIMPLIFIED"),
1715         _T("CHINESE_TRADITIONAL"),
1716         _T("CHINESE_HONGKONG"),
1717         _T("CHINESE_MACAU"),
1718         _T("CHINESE_SINGAPORE"),
1719         _T("CHINESE_TAIWAN"),
1720         _T("CORSICAN"),
1721         _T("CROATIAN"),
1722         _T("CZECH"),
1723         _T("DANISH"),
1724         _T("DUTCH"),
1725         _T("DUTCH_BELGIAN"),
1726         _T("ENGLISH"),
1727         _T("ENGLISH_UK"),
1728         _T("ENGLISH_US"),
1729         _T("ENGLISH_AUSTRALIA"),
1730         _T("ENGLISH_BELIZE"),
1731         _T("ENGLISH_BOTSWANA"),
1732         _T("ENGLISH_CANADA"),
1733         _T("ENGLISH_CARIBBEAN"),
1734         _T("ENGLISH_DENMARK"),
1735         _T("ENGLISH_EIRE"),
1736         _T("ENGLISH_JAMAICA"),
1737         _T("ENGLISH_NEW_ZEALAND"),
1738         _T("ENGLISH_PHILIPPINES"),
1739         _T("ENGLISH_SOUTH_AFRICA"),
1740         _T("ENGLISH_TRINIDAD"),
1741         _T("ENGLISH_ZIMBABWE"),
1742         _T("ESPERANTO"),
1743         _T("ESTONIAN"),
1744         _T("FAEROESE"),
1745         _T("FARSI"),
1746         _T("FIJI"),
1747         _T("FINNISH"),
1748         _T("FRENCH"),
1749         _T("FRENCH_BELGIAN"),
1750         _T("FRENCH_CANADIAN"),
1751         _T("FRENCH_LUXEMBOURG"),
1752         _T("FRENCH_MONACO"),
1753         _T("FRENCH_SWISS"),
1754         _T("FRISIAN"),
1755         _T("GALICIAN"),
1756         _T("GEORGIAN"),
1757         _T("GERMAN"),
1758         _T("GERMAN_AUSTRIAN"),
1759         _T("GERMAN_BELGIUM"),
1760         _T("GERMAN_LIECHTENSTEIN"),
1761         _T("GERMAN_LUXEMBOURG"),
1762         _T("GERMAN_SWISS"),
1763         _T("GREEK"),
1764         _T("GREENLANDIC"),
1765         _T("GUARANI"),
1766         _T("GUJARATI"),
1767         _T("HAUSA"),
1768         _T("HEBREW"),
1769         _T("HINDI"),
1770         _T("HUNGARIAN"),
1771         _T("ICELANDIC"),
1772         _T("INDONESIAN"),
1773         _T("INTERLINGUA"),
1774         _T("INTERLINGUE"),
1775         _T("INUKTITUT"),
1776         _T("INUPIAK"),
1777         _T("IRISH"),
1778         _T("ITALIAN"),
1779         _T("ITALIAN_SWISS"),
1780         _T("JAPANESE"),
1781         _T("JAVANESE"),
1782         _T("KANNADA"),
1783         _T("KASHMIRI"),
1784         _T("KASHMIRI_INDIA"),
1785         _T("KAZAKH"),
1786         _T("KERNEWEK"),
1787         _T("KINYARWANDA"),
1788         _T("KIRGHIZ"),
1789         _T("KIRUNDI"),
1790         _T("KONKANI"),
1791         _T("KOREAN"),
1792         _T("KURDISH"),
1793         _T("LAOTHIAN"),
1794         _T("LATIN"),
1795         _T("LATVIAN"),
1796         _T("LINGALA"),
1797         _T("LITHUANIAN"),
1798         _T("MACEDONIAN"),
1799         _T("MALAGASY"),
1800         _T("MALAY"),
1801         _T("MALAYALAM"),
1802         _T("MALAY_BRUNEI_DARUSSALAM"),
1803         _T("MALAY_MALAYSIA"),
1804         _T("MALTESE"),
1805         _T("MANIPURI"),
1806         _T("MAORI"),
1807         _T("MARATHI"),
1808         _T("MOLDAVIAN"),
1809         _T("MONGOLIAN"),
1810         _T("NAURU"),
1811         _T("NEPALI"),
1812         _T("NEPALI_INDIA"),
1813         _T("NORWEGIAN_BOKMAL"),
1814         _T("NORWEGIAN_NYNORSK"),
1815         _T("OCCITAN"),
1816         _T("ORIYA"),
1817         _T("OROMO"),
1818         _T("PASHTO"),
1819         _T("POLISH"),
1820         _T("PORTUGUESE"),
1821         _T("PORTUGUESE_BRAZILIAN"),
1822         _T("PUNJABI"),
1823         _T("QUECHUA"),
1824         _T("RHAETO_ROMANCE"),
1825         _T("ROMANIAN"),
1826         _T("RUSSIAN"),
1827         _T("RUSSIAN_UKRAINE"),
1828         _T("SAMOAN"),
1829         _T("SANGHO"),
1830         _T("SANSKRIT"),
1831         _T("SCOTS_GAELIC"),
1832         _T("SERBIAN"),
1833         _T("SERBIAN_CYRILLIC"),
1834         _T("SERBIAN_LATIN"),
1835         _T("SERBO_CROATIAN"),
1836         _T("SESOTHO"),
1837         _T("SETSWANA"),
1838         _T("SHONA"),
1839         _T("SINDHI"),
1840         _T("SINHALESE"),
1841         _T("SISWATI"),
1842         _T("SLOVAK"),
1843         _T("SLOVENIAN"),
1844         _T("SOMALI"),
1845         _T("SPANISH"),
1846         _T("SPANISH_ARGENTINA"),
1847         _T("SPANISH_BOLIVIA"),
1848         _T("SPANISH_CHILE"),
1849         _T("SPANISH_COLOMBIA"),
1850         _T("SPANISH_COSTA_RICA"),
1851         _T("SPANISH_DOMINICAN_REPUBLIC"),
1852         _T("SPANISH_ECUADOR"),
1853         _T("SPANISH_EL_SALVADOR"),
1854         _T("SPANISH_GUATEMALA"),
1855         _T("SPANISH_HONDURAS"),
1856         _T("SPANISH_MEXICAN"),
1857         _T("SPANISH_MODERN"),
1858         _T("SPANISH_NICARAGUA"),
1859         _T("SPANISH_PANAMA"),
1860         _T("SPANISH_PARAGUAY"),
1861         _T("SPANISH_PERU"),
1862         _T("SPANISH_PUERTO_RICO"),
1863         _T("SPANISH_URUGUAY"),
1864         _T("SPANISH_US"),
1865         _T("SPANISH_VENEZUELA"),
1866         _T("SUNDANESE"),
1867         _T("SWAHILI"),
1868         _T("SWEDISH"),
1869         _T("SWEDISH_FINLAND"),
1870         _T("TAGALOG"),
1871         _T("TAJIK"),
1872         _T("TAMIL"),
1873         _T("TATAR"),
1874         _T("TELUGU"),
1875         _T("THAI"),
1876         _T("TIBETAN"),
1877         _T("TIGRINYA"),
1878         _T("TONGA"),
1879         _T("TSONGA"),
1880         _T("TURKISH"),
1881         _T("TURKMEN"),
1882         _T("TWI"),
1883         _T("UIGHUR"),
1884         _T("UKRAINIAN"),
1885         _T("URDU"),
1886         _T("URDU_INDIA"),
1887         _T("URDU_PAKISTAN"),
1888         _T("UZBEK"),
1889         _T("UZBEK_CYRILLIC"),
1890         _T("UZBEK_LATIN"),
1891         _T("VIETNAMESE"),
1892         _T("VOLAPUK"),
1893         _T("WELSH"),
1894         _T("WOLOF"),
1895         _T("XHOSA"),
1896         _T("YIDDISH"),
1897         _T("YORUBA"),
1898         _T("ZHUANG"),
1899         _T("ZULU"),
1900     };
1901
1902     if ( (size_t)lang < WXSIZEOF(languageNames) )
1903         return languageNames[lang];
1904     else
1905         return _T("INVALID");
1906 }
1907
1908 static void TestDefaultLang()
1909 {
1910     wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
1911
1912     static const wxChar *langStrings[] =
1913     {
1914         NULL,               // system default
1915         _T("C"),
1916         _T("fr"),
1917         _T("fr_FR"),
1918         _T("en"),
1919         _T("en_GB"),
1920         _T("en_US"),
1921         _T("de_DE.iso88591"),
1922         _T("german"),
1923         _T("?"),            // invalid lang spec
1924         _T("klingonese"),   // I bet on some systems it does exist...
1925     };
1926
1927     wxPrintf(_T("The default system encoding is %s (%d)\n"),
1928              wxLocale::GetSystemEncodingName().c_str(),
1929              wxLocale::GetSystemEncoding());
1930
1931     for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1932     {
1933         const wxChar *langStr = langStrings[n];
1934         if ( langStr )
1935         {
1936             // FIXME: this doesn't do anything at all under Windows, we need
1937             //        to create a new wxLocale!
1938             wxSetEnv(_T("LC_ALL"), langStr);
1939         }
1940
1941         int lang = gs_localeDefault.GetSystemLanguage();
1942         wxPrintf(_T("Locale for '%s' is %s.\n"),
1943                  langStr ? langStr : _T("system default"), GetLangName(lang));
1944     }
1945 }
1946
1947 #endif // TEST_LOCALE
1948
1949 // ----------------------------------------------------------------------------
1950 // MIME types
1951 // ----------------------------------------------------------------------------
1952
1953 #ifdef TEST_MIME
1954
1955 #include "wx/mimetype.h"
1956
1957 static void TestMimeEnum()
1958 {
1959     wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1960
1961     wxArrayString mimetypes;
1962
1963     size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1964
1965     wxPrintf(_T("*** All %u known filetypes: ***\n"), count);
1966
1967     wxArrayString exts;
1968     wxString desc;
1969
1970     for ( size_t n = 0; n < count; n++ )
1971     {
1972         wxFileType *filetype =
1973             wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1974         if ( !filetype )
1975         {
1976             wxPrintf(_T("nothing known about the filetype '%s'!\n"),
1977                    mimetypes[n].c_str());
1978             continue;
1979         }
1980
1981         filetype->GetDescription(&desc);
1982         filetype->GetExtensions(exts);
1983
1984         filetype->GetIcon(NULL);
1985
1986         wxString extsAll;
1987         for ( size_t e = 0; e < exts.GetCount(); e++ )
1988         {
1989             if ( e > 0 )
1990                 extsAll << _T(", ");
1991             extsAll += exts[e];
1992         }
1993
1994         wxPrintf(_T("\t%s: %s (%s)\n"),
1995                mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1996     }
1997
1998     wxPuts(_T(""));
1999 }
2000
2001 static void TestMimeOverride()
2002 {
2003     wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
2004
2005     static const wxChar *mailcap = _T("/tmp/mailcap");
2006     static const wxChar *mimetypes = _T("/tmp/mime.types");
2007
2008     if ( wxFile::Exists(mailcap) )
2009         wxPrintf(_T("Loading mailcap from '%s': %s\n"),
2010                  mailcap,
2011                  wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
2012     else
2013         wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
2014                  mailcap);
2015
2016     if ( wxFile::Exists(mimetypes) )
2017         wxPrintf(_T("Loading mime.types from '%s': %s\n"),
2018                  mimetypes,
2019                  wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
2020     else
2021         wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
2022                  mimetypes);
2023
2024     wxPuts(_T(""));
2025 }
2026
2027 static void TestMimeFilename()
2028 {
2029     wxPuts(_T("*** Testing MIME type from filename query ***\n"));
2030
2031     static const wxChar *filenames[] =
2032     {
2033         _T("readme.txt"),
2034         _T("document.pdf"),
2035         _T("image.gif"),
2036         _T("picture.jpeg"),
2037     };
2038
2039     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
2040     {
2041         const wxString fname = filenames[n];
2042         wxString ext = fname.AfterLast(_T('.'));
2043         wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
2044         if ( !ft )
2045         {
2046             wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
2047         }
2048         else
2049         {
2050             wxString desc;
2051             if ( !ft->GetDescription(&desc) )
2052                 desc = _T("<no description>");
2053
2054             wxString cmd;
2055             if ( !ft->GetOpenCommand(&cmd,
2056                                      wxFileType::MessageParameters(fname, _T(""))) )
2057                 cmd = _T("<no command available>");
2058             else
2059                 cmd = wxString(_T('"')) + cmd + _T('"');
2060
2061             wxPrintf(_T("To open %s (%s) do %s.\n"),
2062                      fname.c_str(), desc.c_str(), cmd.c_str());
2063
2064             delete ft;
2065         }
2066     }
2067
2068     wxPuts(_T(""));
2069 }
2070
2071 static void TestMimeAssociate()
2072 {
2073     wxPuts(_T("*** Testing creation of filetype association ***\n"));
2074
2075     wxFileTypeInfo ftInfo(
2076                             _T("application/x-xyz"),
2077                             _T("xyzview '%s'"), // open cmd
2078                             _T(""),             // print cmd
2079                             _T("XYZ File"),     // description
2080                             _T(".xyz"),         // extensions
2081                             NULL                // end of extensions
2082                          );
2083     ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
2084
2085     wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
2086     if ( !ft )
2087     {
2088         wxPuts(_T("ERROR: failed to create association!"));
2089     }
2090     else
2091     {
2092         // TODO: read it back
2093         delete ft;
2094     }
2095
2096     wxPuts(_T(""));
2097 }
2098
2099 #endif // TEST_MIME
2100
2101 // ----------------------------------------------------------------------------
2102 // misc information functions
2103 // ----------------------------------------------------------------------------
2104
2105 #ifdef TEST_INFO_FUNCTIONS
2106
2107 #include "wx/utils.h"
2108
2109 static void TestDiskInfo()
2110 {
2111     wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
2112
2113     for ( ;; )
2114     {
2115         wxChar pathname[128];
2116         wxPrintf(_T("\nEnter a directory name: "));
2117         if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
2118             break;
2119
2120         // kill the last '\n'
2121         pathname[wxStrlen(pathname) - 1] = 0;
2122
2123         wxLongLong total, free;
2124         if ( !wxGetDiskSpace(pathname, &total, &free) )
2125         {
2126             wxPuts(_T("ERROR: wxGetDiskSpace failed."));
2127         }
2128         else
2129         {
2130             wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
2131                     (total / 1024).ToString().c_str(),
2132                     (free / 1024).ToString().c_str(),
2133                     pathname);
2134         }
2135     }
2136 }
2137
2138 static void TestOsInfo()
2139 {
2140     wxPuts(_T("*** Testing OS info functions ***\n"));
2141
2142     int major, minor;
2143     wxGetOsVersion(&major, &minor);
2144     wxPrintf(_T("Running under: %s, version %d.%d\n"),
2145             wxGetOsDescription().c_str(), major, minor);
2146
2147     wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory());
2148
2149     wxPrintf(_T("Host name is %s (%s).\n"),
2150            wxGetHostName().c_str(), wxGetFullHostName().c_str());
2151
2152     wxPuts(_T(""));
2153 }
2154
2155 static void TestUserInfo()
2156 {
2157     wxPuts(_T("*** Testing user info functions ***\n"));
2158
2159     wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
2160     wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
2161     wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
2162     wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
2163
2164     wxPuts(_T(""));
2165 }
2166
2167 #endif // TEST_INFO_FUNCTIONS
2168
2169 // ----------------------------------------------------------------------------
2170 // long long
2171 // ----------------------------------------------------------------------------
2172
2173 #ifdef TEST_LONGLONG
2174
2175 #include "wx/longlong.h"
2176 #include "wx/timer.h"
2177
2178 // make a 64 bit number from 4 16 bit ones
2179 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
2180
2181 // get a random 64 bit number
2182 #define RAND_LL()   MAKE_LL(rand(), rand(), rand(), rand())
2183
2184 static const long testLongs[] =
2185 {
2186     0,
2187     1,
2188     -1,
2189     LONG_MAX,
2190     LONG_MIN,
2191     0x1234,
2192     -0x1234
2193 };
2194
2195 #if wxUSE_LONGLONG_WX
2196 inline bool operator==(const wxLongLongWx& a, const wxLongLongNative& b)
2197     { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
2198 inline bool operator==(const wxLongLongNative& a, const wxLongLongWx& b)
2199     { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
2200 #endif // wxUSE_LONGLONG_WX
2201
2202 static void TestSpeed()
2203 {
2204     static const long max = 100000000;
2205     long n;
2206
2207     {
2208         wxStopWatch sw;
2209
2210         long l = 0;
2211         for ( n = 0; n < max; n++ )
2212         {
2213             l += n;
2214         }
2215
2216         wxPrintf(_T("Summing longs took %ld milliseconds.\n"), sw.Time());
2217     }
2218
2219 #if wxUSE_LONGLONG_NATIVE
2220     {
2221         wxStopWatch sw;
2222
2223         wxLongLong_t l = 0;
2224         for ( n = 0; n < max; n++ )
2225         {
2226             l += n;
2227         }
2228
2229         wxPrintf(_T("Summing wxLongLong_t took %ld milliseconds.\n"), sw.Time());
2230     }
2231 #endif // wxUSE_LONGLONG_NATIVE
2232
2233     {
2234         wxStopWatch sw;
2235
2236         wxLongLong l;
2237         for ( n = 0; n < max; n++ )
2238         {
2239             l += n;
2240         }
2241
2242         wxPrintf(_T("Summing wxLongLongs took %ld milliseconds.\n"), sw.Time());
2243     }
2244 }
2245
2246 static void TestLongLongConversion()
2247 {
2248     wxPuts(_T("*** Testing wxLongLong conversions ***\n"));
2249
2250     wxLongLong a;
2251     size_t nTested = 0;
2252     for ( size_t n = 0; n < 100000; n++ )
2253     {
2254         a = RAND_LL();
2255
2256 #if wxUSE_LONGLONG_NATIVE
2257         wxLongLongNative b(a.GetHi(), a.GetLo());
2258
2259         wxASSERT_MSG( a == b, _T("conversions failure") );
2260 #else
2261         wxPuts(_T("Can't do it without native long long type, test skipped."));
2262
2263         return;
2264 #endif // wxUSE_LONGLONG_NATIVE
2265
2266         if ( !(nTested % 1000) )
2267         {
2268             putchar('.');
2269             fflush(stdout);
2270         }
2271
2272         nTested++;
2273     }
2274
2275     wxPuts(_T(" done!"));
2276 }
2277
2278 static void TestMultiplication()
2279 {
2280     wxPuts(_T("*** Testing wxLongLong multiplication ***\n"));
2281
2282     wxLongLong a, b;
2283     size_t nTested = 0;
2284     for ( size_t n = 0; n < 100000; n++ )
2285     {
2286         a = RAND_LL();
2287         b = RAND_LL();
2288
2289 #if wxUSE_LONGLONG_NATIVE
2290         wxLongLongNative aa(a.GetHi(), a.GetLo());
2291         wxLongLongNative bb(b.GetHi(), b.GetLo());
2292
2293         wxASSERT_MSG( a*b == aa*bb, _T("multiplication failure") );
2294 #else // !wxUSE_LONGLONG_NATIVE
2295         wxPuts(_T("Can't do it without native long long type, test skipped."));
2296
2297         return;
2298 #endif // wxUSE_LONGLONG_NATIVE
2299
2300         if ( !(nTested % 1000) )
2301         {
2302             putchar('.');
2303             fflush(stdout);
2304         }
2305
2306         nTested++;
2307     }
2308
2309     wxPuts(_T(" done!"));
2310 }
2311
2312 static void TestDivision()
2313 {
2314     wxPuts(_T("*** Testing wxLongLong division ***\n"));
2315
2316     wxLongLong q, r;
2317     size_t nTested = 0;
2318     for ( size_t n = 0; n < 100000; n++ )
2319     {
2320         // get a random wxLongLong (shifting by 12 the MSB ensures that the
2321         // multiplication will not overflow)
2322         wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
2323
2324         // get a random (but non null) long (not wxLongLong for now) to divide
2325         // it with
2326         long l;
2327         do
2328         {
2329            l = rand();
2330         }
2331         while ( !l );
2332
2333         q = ll / l;
2334         r = ll % l;
2335
2336 #if wxUSE_LONGLONG_NATIVE
2337         wxLongLongNative m(ll.GetHi(), ll.GetLo());
2338
2339         wxLongLongNative p = m / l, s = m % l;
2340         wxASSERT_MSG( q == p && r == s, _T("division failure") );
2341 #else // !wxUSE_LONGLONG_NATIVE
2342         // verify the result
2343         wxASSERT_MSG( ll == q*l + r, "division failure" );
2344 #endif // wxUSE_LONGLONG_NATIVE
2345
2346         if ( !(nTested % 1000) )
2347         {
2348             putchar('.');
2349             fflush(stdout);
2350         }
2351
2352         nTested++;
2353     }
2354
2355     wxPuts(_T(" done!"));
2356 }
2357
2358 static void TestAddition()
2359 {
2360     wxPuts(_T("*** Testing wxLongLong addition ***\n"));
2361
2362     wxLongLong a, b, c;
2363     size_t nTested = 0;
2364     for ( size_t n = 0; n < 100000; n++ )
2365     {
2366         a = RAND_LL();
2367         b = RAND_LL();
2368         c = a + b;
2369
2370 #if wxUSE_LONGLONG_NATIVE
2371         wxASSERT_MSG( c == wxLongLongNative(a.GetHi(), a.GetLo()) +
2372                            wxLongLongNative(b.GetHi(), b.GetLo()),
2373                       _T("addition failure") );
2374 #else // !wxUSE_LONGLONG_NATIVE
2375         wxASSERT_MSG( c - b == a, "addition failure" );
2376 #endif // wxUSE_LONGLONG_NATIVE
2377
2378         if ( !(nTested % 1000) )
2379         {
2380             putchar('.');
2381             fflush(stdout);
2382         }
2383
2384         nTested++;
2385     }
2386
2387     wxPuts(_T(" done!"));
2388 }
2389
2390 static void TestBitOperations()
2391 {
2392     wxPuts(_T("*** Testing wxLongLong bit operation ***\n"));
2393
2394     wxLongLong ll;
2395     size_t nTested = 0;
2396     for ( size_t n = 0; n < 100000; n++ )
2397     {
2398         ll = RAND_LL();
2399
2400 #if wxUSE_LONGLONG_NATIVE
2401         for ( size_t n = 0; n < 33; n++ )
2402         {
2403         }
2404 #else // !wxUSE_LONGLONG_NATIVE
2405         wxPuts(_T("Can't do it without native long long type, test skipped."));
2406
2407         return;
2408 #endif // wxUSE_LONGLONG_NATIVE
2409
2410         if ( !(nTested % 1000) )
2411         {
2412             putchar('.');
2413             fflush(stdout);
2414         }
2415
2416         nTested++;
2417     }
2418
2419     wxPuts(_T(" done!"));
2420 }
2421
2422 static void TestLongLongComparison()
2423 {
2424 #if wxUSE_LONGLONG_WX
2425     wxPuts(_T("*** Testing wxLongLong comparison ***\n"));
2426
2427     static const long ls[2] =
2428     {
2429         0x1234,
2430        -0x1234,
2431     };
2432
2433     wxLongLongWx lls[2];
2434     lls[0] = ls[0];
2435     lls[1] = ls[1];
2436
2437     for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
2438     {
2439         bool res;
2440
2441         for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
2442         {
2443             res = lls[m] > testLongs[n];
2444             wxPrintf(_T("0x%lx > 0x%lx is %s (%s)\n"),
2445                    ls[m], testLongs[n], res ? "true" : "false",
2446                    res == (ls[m] > testLongs[n]) ? "ok" : "ERROR");
2447
2448             res = lls[m] < testLongs[n];
2449             wxPrintf(_T("0x%lx < 0x%lx is %s (%s)\n"),
2450                    ls[m], testLongs[n], res ? "true" : "false",
2451                    res == (ls[m] < testLongs[n]) ? "ok" : "ERROR");
2452
2453             res = lls[m] == testLongs[n];
2454             wxPrintf(_T("0x%lx == 0x%lx is %s (%s)\n"),
2455                    ls[m], testLongs[n], res ? "true" : "false",
2456                    res == (ls[m] == testLongs[n]) ? "ok" : "ERROR");
2457         }
2458     }
2459 #endif // wxUSE_LONGLONG_WX
2460 }
2461
2462 static void TestLongLongToString()
2463 {
2464     wxPuts(_T("*** Testing wxLongLong::ToString() ***\n"));
2465
2466     for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
2467     {
2468         wxLongLong ll = testLongs[n];
2469         wxPrintf(_T("%ld == %s\n"), testLongs[n], ll.ToString().c_str());
2470     }
2471
2472     wxLongLong ll(0x12345678, 0x87654321);
2473     wxPrintf(_T("0x1234567887654321 = %s\n"), ll.ToString().c_str());
2474
2475     ll.Negate();
2476     wxPrintf(_T("-0x1234567887654321 = %s\n"), ll.ToString().c_str());
2477 }
2478
2479 static void TestLongLongPrintf()
2480 {
2481     wxPuts(_T("*** Testing wxLongLong printing ***\n"));
2482
2483 #ifdef wxLongLongFmtSpec
2484     wxLongLong ll = wxLL(0x1234567890abcdef);
2485     wxString s = wxString::Format(_T("%") wxLongLongFmtSpec _T("x"), ll);
2486     wxPrintf(_T("0x1234567890abcdef -> %s (%s)\n"),
2487              s.c_str(), s == _T("1234567890abcdef") ? _T("ok") : _T("ERROR"));
2488 #else // !wxLongLongFmtSpec
2489     #error "wxLongLongFmtSpec not defined for this compiler/platform"
2490 #endif
2491 }
2492
2493 #undef MAKE_LL
2494 #undef RAND_LL
2495
2496 #endif // TEST_LONGLONG
2497
2498 // ----------------------------------------------------------------------------
2499 // path list
2500 // ----------------------------------------------------------------------------
2501
2502 #ifdef TEST_PATHLIST
2503
2504 #ifdef __UNIX__
2505     #define CMD_IN_PATH _T("ls")
2506 #else
2507     #define CMD_IN_PATH _T("command.com")
2508 #endif
2509
2510 static void TestPathList()
2511 {
2512     wxPuts(_T("*** Testing wxPathList ***\n"));
2513
2514     wxPathList pathlist;
2515     pathlist.AddEnvList(_T("PATH"));
2516     wxString path = pathlist.FindValidPath(CMD_IN_PATH);
2517     if ( path.empty() )
2518     {
2519         wxPrintf(_T("ERROR: command not found in the path.\n"));
2520     }
2521     else
2522     {
2523         wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
2524     }
2525 }
2526
2527 #endif // TEST_PATHLIST
2528
2529 // ----------------------------------------------------------------------------
2530 // regular expressions
2531 // ----------------------------------------------------------------------------
2532
2533 #ifdef TEST_REGEX
2534
2535 #include "wx/regex.h"
2536
2537 static void TestRegExCompile()
2538 {
2539     wxPuts(_T("*** Testing RE compilation ***\n"));
2540
2541     static struct RegExCompTestData
2542     {
2543         const wxChar *pattern;
2544         bool correct;
2545     } regExCompTestData[] =
2546     {
2547         { _T("foo"), true },
2548         { _T("foo("), false },
2549         { _T("foo(bar"), false },
2550         { _T("foo(bar)"), true },
2551         { _T("foo["), false },
2552         { _T("foo[bar"), false },
2553         { _T("foo[bar]"), true },
2554         { _T("foo{"), true },
2555         { _T("foo{1"), false },
2556         { _T("foo{bar"), true },
2557         { _T("foo{1}"), true },
2558         { _T("foo{1,2}"), true },
2559         { _T("foo{bar}"), true },
2560         { _T("foo*"), true },
2561         { _T("foo**"), false },
2562         { _T("foo+"), true },
2563         { _T("foo++"), false },
2564         { _T("foo?"), true },
2565         { _T("foo??"), false },
2566         { _T("foo?+"), false },
2567     };
2568
2569     wxRegEx re;
2570     for ( size_t n = 0; n < WXSIZEOF(regExCompTestData); n++ )
2571     {
2572         const RegExCompTestData& data = regExCompTestData[n];
2573         bool ok = re.Compile(data.pattern);
2574
2575         wxPrintf(_T("'%s' is %sa valid RE (%s)\n"),
2576                  data.pattern,
2577                  ok ? _T("") : _T("not "),
2578                  ok == data.correct ? _T("ok") : _T("ERROR"));
2579     }
2580 }
2581
2582 static void TestRegExMatch()
2583 {
2584     wxPuts(_T("*** Testing RE matching ***\n"));
2585
2586     static struct RegExMatchTestData
2587     {
2588         const wxChar *pattern;
2589         const wxChar *text;
2590         bool correct;
2591     } regExMatchTestData[] =
2592     {
2593         { _T("foo"), _T("bar"), false },
2594         { _T("foo"), _T("foobar"), true },
2595         { _T("^foo"), _T("foobar"), true },
2596         { _T("^foo"), _T("barfoo"), false },
2597         { _T("bar$"), _T("barbar"), true },
2598         { _T("bar$"), _T("barbar "), false },
2599     };
2600
2601     for ( size_t n = 0; n < WXSIZEOF(regExMatchTestData); n++ )
2602     {
2603         const RegExMatchTestData& data = regExMatchTestData[n];
2604
2605         wxRegEx re(data.pattern);
2606         bool ok = re.Matches(data.text);
2607
2608         wxPrintf(_T("'%s' %s %s (%s)\n"),
2609                  data.pattern,
2610                  ok ? _T("matches") : _T("doesn't match"),
2611                  data.text,
2612                  ok == data.correct ? _T("ok") : _T("ERROR"));
2613     }
2614 }
2615
2616 static void TestRegExSubmatch()
2617 {
2618     wxPuts(_T("*** Testing RE subexpressions ***\n"));
2619
2620     wxRegEx re(_T("([[:alpha:]]+) ([[:alpha:]]+) ([[:digit:]]+).*([[:digit:]]+)$"));
2621     if ( !re.IsValid() )
2622     {
2623         wxPuts(_T("ERROR: compilation failed."));
2624         return;
2625     }
2626
2627     wxString text = _T("Fri Jul 13 18:37:52 CEST 2001");
2628
2629     if ( !re.Matches(text) )
2630     {
2631         wxPuts(_T("ERROR: match expected."));
2632     }
2633     else
2634     {
2635         wxPrintf(_T("Entire match: %s\n"), re.GetMatch(text).c_str());
2636
2637         wxPrintf(_T("Date: %s/%s/%s, wday: %s\n"),
2638                  re.GetMatch(text, 3).c_str(),
2639                  re.GetMatch(text, 2).c_str(),
2640                  re.GetMatch(text, 4).c_str(),
2641                  re.GetMatch(text, 1).c_str());
2642     }
2643 }
2644
2645 static void TestRegExReplacement()
2646 {
2647     wxPuts(_T("*** Testing RE replacement ***"));
2648
2649     static struct RegExReplTestData
2650     {
2651         const wxChar *text;
2652         const wxChar *repl;
2653         const wxChar *result;
2654         size_t count;
2655     } regExReplTestData[] =
2656     {
2657         { _T("foo123"), _T("bar"), _T("bar"), 1 },
2658         { _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
2659         { _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
2660         { _T("123foo"), _T("bar"), _T("123foo"), 0 },
2661         { _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
2662         { _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
2663         { _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
2664     };
2665
2666     const wxChar *pattern = _T("([a-z]+)[^0-9]*([0-9]+)");
2667     wxRegEx re(pattern);
2668
2669     wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern);
2670
2671     for ( size_t n = 0; n < WXSIZEOF(regExReplTestData); n++ )
2672     {
2673         const RegExReplTestData& data = regExReplTestData[n];
2674
2675         wxString text = data.text;
2676         size_t nRepl = re.Replace(&text, data.repl);
2677
2678         wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
2679                  data.text, data.repl,
2680                  nRepl, nRepl == 1 ? _T("") : _T("es"),
2681                  text.c_str());
2682         if ( text == data.result && nRepl == data.count )
2683         {
2684             wxPuts(_T("ok)"));
2685         }
2686         else
2687         {
2688             wxPrintf(_T("ERROR: should be %u and '%s')\n"),
2689                      data.count, data.result);
2690         }
2691     }
2692 }
2693
2694 static void TestRegExInteractive()
2695 {
2696     wxPuts(_T("*** Testing RE interactively ***"));
2697
2698     for ( ;; )
2699     {
2700         wxChar pattern[128];
2701         wxPrintf(_T("\nEnter a pattern: "));
2702         if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
2703             break;
2704
2705         // kill the last '\n'
2706         pattern[wxStrlen(pattern) - 1] = 0;
2707
2708         wxRegEx re;
2709         if ( !re.Compile(pattern) )
2710         {
2711             continue;
2712         }
2713
2714         wxChar text[128];
2715         for ( ;; )
2716         {
2717             wxPrintf(_T("Enter text to match: "));
2718             if ( !wxFgets(text, WXSIZEOF(text), stdin) )
2719                 break;
2720
2721             // kill the last '\n'
2722             text[wxStrlen(text) - 1] = 0;
2723
2724             if ( !re.Matches(text) )
2725             {
2726                 wxPrintf(_T("No match.\n"));
2727             }
2728             else
2729             {
2730                 wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
2731
2732                 size_t start, len;
2733                 for ( size_t n = 1; ; n++ )
2734                 {
2735                     if ( !re.GetMatch(&start, &len, n) )
2736                     {
2737                         break;
2738                     }
2739
2740                     wxPrintf(_T("Subexpr %u matched '%s'\n"),
2741                              n, wxString(text + start, len).c_str());
2742                 }
2743             }
2744         }
2745     }
2746 }
2747
2748 #endif // TEST_REGEX
2749
2750 // ----------------------------------------------------------------------------
2751 // database
2752 // ----------------------------------------------------------------------------
2753
2754 #if !wxUSE_ODBC
2755     #undef TEST_ODBC
2756 #endif
2757
2758 #ifdef TEST_ODBC
2759
2760 #include <wx/db.h>
2761
2762 static void TestDbOpen()
2763 {
2764     HENV henv;
2765     wxDb db(henv);
2766 }
2767
2768 #endif // TEST_ODBC
2769
2770 // ----------------------------------------------------------------------------
2771 // printf() tests
2772 // ----------------------------------------------------------------------------
2773
2774 /*
2775    NB: this stuff was taken from the glibc test suite and modified to build
2776        in wxWindows: if I read the copyright below properly, this shouldn't
2777        be a problem
2778  */
2779
2780 #ifdef TEST_PRINTF
2781
2782 #ifdef wxTEST_PRINTF
2783     // use our functions from wxchar.cpp
2784     #undef wxPrintf
2785     #undef wxSprintf
2786
2787     // NB: do _not_ use ATTRIBUTE_PRINTF here, we have some invalid formats
2788     //     in the tests below
2789     int wxPrintf( const wxChar *format, ... );
2790     int wxSprintf( wxChar *str, const wxChar *format, ... );
2791 #endif
2792
2793 #include "wx/longlong.h"
2794
2795 #include <float.h>
2796
2797 static void rfg1 (void);
2798 static void rfg2 (void);
2799
2800
2801 static void
2802 fmtchk (const wxChar *fmt)
2803 {
2804   (void) wxPrintf(_T("%s:\t`"), fmt);
2805   (void) wxPrintf(fmt, 0x12);
2806   (void) wxPrintf(_T("'\n"));
2807 }
2808
2809 static void
2810 fmtst1chk (const wxChar *fmt)
2811 {
2812   (void) wxPrintf(_T("%s:\t`"), fmt);
2813   (void) wxPrintf(fmt, 4, 0x12);
2814   (void) wxPrintf(_T("'\n"));
2815 }
2816
2817 static void
2818 fmtst2chk (const wxChar *fmt)
2819 {
2820   (void) wxPrintf(_T("%s:\t`"), fmt);
2821   (void) wxPrintf(fmt, 4, 4, 0x12);
2822   (void) wxPrintf(_T("'\n"));
2823 }
2824
2825 /* This page is covered by the following copyright: */
2826
2827 /* (C) Copyright C E Chew
2828  *
2829  * Feel free to copy, use and distribute this software provided:
2830  *
2831  *        1. you do not pretend that you wrote it
2832  *        2. you leave this copyright notice intact.
2833  */
2834
2835 /*
2836  * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
2837  */
2838
2839 #define DEC -123
2840 #define INT 255
2841 #define UNS (~0)
2842
2843 /* Formatted Output Test
2844  *
2845  * This exercises the output formatting code.
2846  */
2847
2848 static void
2849 fp_test (void)
2850 {
2851   int i, j, k, l;
2852   wxChar buf[7];
2853   wxChar *prefix = buf;
2854   wxChar tp[20];
2855
2856   wxPuts(_T("\nFormatted output test"));
2857   wxPrintf(_T("prefix  6d      6o      6x      6X      6u\n"));
2858   wxStrcpy(prefix, _T("%"));
2859   for (i = 0; i < 2; i++) {
2860     for (j = 0; j < 2; j++) {
2861       for (k = 0; k < 2; k++) {
2862         for (l = 0; l < 2; l++) {
2863           wxStrcpy(prefix, _T("%"));
2864           if (i == 0) wxStrcat(prefix, _T("-"));
2865           if (j == 0) wxStrcat(prefix, _T("+"));
2866           if (k == 0) wxStrcat(prefix, _T("#"));
2867           if (l == 0) wxStrcat(prefix, _T("0"));
2868           wxPrintf(_T("%5s |"), prefix);
2869           wxStrcpy(tp, prefix);
2870           wxStrcat(tp, _T("6d |"));
2871           wxPrintf(tp, DEC);
2872           wxStrcpy(tp, prefix);
2873           wxStrcat(tp, _T("6o |"));
2874           wxPrintf(tp, INT);
2875           wxStrcpy(tp, prefix);
2876           wxStrcat(tp, _T("6x |"));
2877           wxPrintf(tp, INT);
2878           wxStrcpy(tp, prefix);
2879           wxStrcat(tp, _T("6X |"));
2880           wxPrintf(tp, INT);
2881           wxStrcpy(tp, prefix);
2882           wxStrcat(tp, _T("6u |"));
2883           wxPrintf(tp, UNS);
2884           wxPrintf(_T("\n"));
2885         }
2886       }
2887     }
2888   }
2889   wxPrintf(_T("%10s\n"), (wxChar *) NULL);
2890   wxPrintf(_T("%-10s\n"), (wxChar *) NULL);
2891 }
2892
2893 static void TestPrintf()
2894 {
2895   static wxChar shortstr[] = _T("Hi, Z.");
2896   static wxChar longstr[] = _T("Good morning, Doctor Chandra.  This is Hal.  \
2897 I am ready for my first lesson today.");
2898   int result = 0;
2899
2900   fmtchk(_T("%.4x"));
2901   fmtchk(_T("%04x"));
2902   fmtchk(_T("%4.4x"));
2903   fmtchk(_T("%04.4x"));
2904   fmtchk(_T("%4.3x"));
2905   fmtchk(_T("%04.3x"));
2906
2907   fmtst1chk(_T("%.*x"));
2908   fmtst1chk(_T("%0*x"));
2909   fmtst2chk(_T("%*.*x"));
2910   fmtst2chk(_T("%0*.*x"));
2911
2912   wxPrintf(_T("bad format:\t\"%b\"\n"));
2913   wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
2914
2915   wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
2916   wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
2917   wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
2918   wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
2919   wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
2920   wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
2921   wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
2922   wxPrintf(_T("left-adjusted ZLDN:\t\"%-010ld\"\n"), -123456);
2923   wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
2924   wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
2925
2926   wxPrintf(_T("zero-padded string:\t\"%010s\"\n"), shortstr);
2927   wxPrintf(_T("left-adjusted Z string:\t\"%-010s\"\n"), shortstr);
2928   wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
2929   wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
2930   wxPrintf(_T("null string:\t\"%s\"\n"), (wxChar *)NULL);
2931   wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr);
2932
2933   wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
2934   wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
2935   wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
2936   wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20);
2937   wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
2938   wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
2939   wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
2940   wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
2941   wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
2942   wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
2943   wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
2944   wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20);
2945
2946   wxPrintf (_T(" %6.5f\n"), .099999999860301614);
2947   wxPrintf (_T(" %6.5f\n"), .1);
2948   wxPrintf (_T("x%5.4fx\n"), .5);
2949
2950   wxPrintf (_T("%#03x\n"), 1);
2951
2952   //wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
2953
2954   {
2955     double d = FLT_MIN;
2956     int niter = 17;
2957
2958     while (niter-- != 0)
2959       wxPrintf (_T("%.17e\n"), d / 2);
2960     fflush (stdout);
2961   }
2962
2963   wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
2964
2965 #define FORMAT _T("|%12.4f|%12.4e|%12.4g|\n")
2966   wxPrintf (FORMAT, 0.0, 0.0, 0.0);
2967   wxPrintf (FORMAT, 1.0, 1.0, 1.0);
2968   wxPrintf (FORMAT, -1.0, -1.0, -1.0);
2969   wxPrintf (FORMAT, 100.0, 100.0, 100.0);
2970   wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
2971   wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
2972   wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
2973   wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
2974   wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
2975 #undef        FORMAT
2976
2977   {
2978     wxChar buf[20];
2979     int rc = wxSnprintf (buf, WXSIZEOF(buf), _T("%30s"), _T("foo"));
2980
2981     wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
2982              rc, WXSIZEOF(buf), buf);
2983 #if 0
2984     wxChar buf2[512];
2985     wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
2986             wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
2987 #endif
2988   }
2989
2990   fp_test ();
2991
2992   wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
2993   wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
2994   wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
2995   wxPrintf (_T("%g should be 123.456\n"), 123.456);
2996   wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
2997   wxPrintf (_T("%g should be 10\n"), 10.0);
2998   wxPrintf (_T("%g should be 0.02\n"), 0.02);
2999
3000   {
3001     double x=1.0;
3002     wxPrintf(_T("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
3003   }
3004
3005   {
3006     wxChar buf[200];
3007
3008     wxSprintf(buf,_T("%*s%*s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
3009
3010     result |= wxStrcmp (buf,
3011                       _T("onetwo                 three                         "));
3012
3013     wxPuts (result != 0 ? _T("Test failed!") : _T("Test ok."));
3014   }
3015
3016 #ifdef wxLongLong_t
3017   {
3018       wxChar buf[200];
3019
3020       wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
3021       #if 0
3022         // for some reason below line fails under Borland
3023       wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
3024       #endif
3025
3026       if (wxStrcmp (buf, _T("40000000000")) != 0)
3027       {
3028           result = 1;
3029           wxPuts (_T("\tFAILED"));
3030       }
3031       wxPuts (_T(""));
3032   }
3033 #endif // wxLongLong_t
3034
3035   wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
3036   wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
3037
3038   wxPuts (_T("--- Should be no further output. ---"));
3039   rfg1 ();
3040   rfg2 ();
3041
3042 #if 0
3043   {
3044     wxChar bytes[7];
3045     wxChar buf[20];
3046
3047     memset (bytes, '\xff', sizeof bytes);
3048     wxSprintf (buf, _T("foo%hhn\n"), &bytes[3]);
3049     if (bytes[0] != '\xff' || bytes[1] != '\xff' || bytes[2] != '\xff'
3050         || bytes[4] != '\xff' || bytes[5] != '\xff' || bytes[6] != '\xff')
3051       {
3052         wxPuts (_T("%hhn overwrite more bytes"));
3053         result = 1;
3054       }
3055     if (bytes[3] != 3)
3056       {
3057         wxPuts (_T("%hhn wrote incorrect value"));
3058         result = 1;
3059       }
3060   }
3061 #endif
3062 }
3063
3064 static void
3065 rfg1 (void)
3066 {
3067   wxChar buf[100];
3068
3069   wxSprintf (buf, _T("%5.s"), _T("xyz"));
3070   if (wxStrcmp (buf, _T("     ")) != 0)
3071     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("     "));
3072   wxSprintf (buf, _T("%5.f"), 33.3);
3073   if (wxStrcmp (buf, _T("   33")) != 0)
3074     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   33"));
3075   wxSprintf (buf, _T("%8.e"), 33.3e7);
3076   if (wxStrcmp (buf, _T("   3e+08")) != 0)
3077     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   3e+08"));
3078   wxSprintf (buf, _T("%8.E"), 33.3e7);
3079   if (wxStrcmp (buf, _T("   3E+08")) != 0)
3080     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   3E+08"));
3081   wxSprintf (buf, _T("%.g"), 33.3);
3082   if (wxStrcmp (buf, _T("3e+01")) != 0)
3083     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3e+01"));
3084   wxSprintf (buf, _T("%.G"), 33.3);
3085   if (wxStrcmp (buf, _T("3E+01")) != 0)
3086     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3E+01"));
3087 }
3088
3089 static void
3090 rfg2 (void)
3091 {
3092   int prec;
3093   wxChar buf[100];
3094
3095   prec = 0;
3096   wxSprintf (buf, _T("%.*g"), prec, 3.3);
3097   if (wxStrcmp (buf, _T("3")) != 0)
3098     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
3099   prec = 0;
3100   wxSprintf (buf, _T("%.*G"), prec, 3.3);
3101   if (wxStrcmp (buf, _T("3")) != 0)
3102     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
3103   prec = 0;
3104   wxSprintf (buf, _T("%7.*G"), prec, 3.33);
3105   if (wxStrcmp (buf, _T("      3")) != 0)
3106     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("      3"));
3107   prec = 3;
3108   wxSprintf (buf, _T("%04.*o"), prec, 33);
3109   if (wxStrcmp (buf, _T(" 041")) != 0)
3110     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
3111   prec = 7;
3112   wxSprintf (buf, _T("%09.*u"), prec, 33);
3113   if (wxStrcmp (buf, _T("  0000033")) != 0)
3114     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("  0000033"));
3115   prec = 3;
3116   wxSprintf (buf, _T("%04.*x"), prec, 33);
3117   if (wxStrcmp (buf, _T(" 021")) != 0)
3118     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
3119   prec = 3;
3120   wxSprintf (buf, _T("%04.*X"), prec, 33);
3121   if (wxStrcmp (buf, _T(" 021")) != 0)
3122     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
3123 }
3124
3125 #endif // TEST_PRINTF
3126
3127 // ----------------------------------------------------------------------------
3128 // registry and related stuff
3129 // ----------------------------------------------------------------------------
3130
3131 // this is for MSW only
3132 #ifndef __WXMSW__
3133     #undef TEST_REGCONF
3134     #undef TEST_REGISTRY
3135 #endif
3136
3137 #ifdef TEST_REGCONF
3138
3139 #include "wx/confbase.h"
3140 #include "wx/msw/regconf.h"
3141
3142 static void TestRegConfWrite()
3143 {
3144     wxRegConfig regconf(_T("console"), _T("wxwindows"));
3145     regconf.Write(_T("Hello"), wxString(_T("world")));
3146 }
3147
3148 #endif // TEST_REGCONF
3149
3150 #ifdef TEST_REGISTRY
3151
3152 #include "wx/msw/registry.h"
3153
3154 // I chose this one because I liked its name, but it probably only exists under
3155 // NT
3156 static const wxChar *TESTKEY =
3157     _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
3158
3159 static void TestRegistryRead()
3160 {
3161     wxPuts(_T("*** testing registry reading ***"));
3162
3163     wxRegKey key(TESTKEY);
3164     wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
3165     if ( !key.Open() )
3166     {
3167         wxPuts(_T("ERROR: test key can't be opened, aborting test."));
3168
3169         return;
3170     }
3171
3172     size_t nSubKeys, nValues;
3173     if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
3174     {
3175         wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
3176     }
3177
3178     wxPrintf(_T("Enumerating values:\n"));
3179
3180     long dummy;
3181     wxString value;
3182     bool cont = key.GetFirstValue(value, dummy);
3183     while ( cont )
3184     {
3185         wxPrintf(_T("Value '%s': type "), value.c_str());
3186         switch ( key.GetValueType(value) )
3187         {
3188             case wxRegKey::Type_None:   wxPrintf(_T("ERROR (none)")); break;
3189             case wxRegKey::Type_String: wxPrintf(_T("SZ")); break;
3190             case wxRegKey::Type_Expand_String: wxPrintf(_T("EXPAND_SZ")); break;
3191             case wxRegKey::Type_Binary: wxPrintf(_T("BINARY")); break;
3192             case wxRegKey::Type_Dword: wxPrintf(_T("DWORD")); break;
3193             case wxRegKey::Type_Multi_String: wxPrintf(_T("MULTI_SZ")); break;
3194             default: wxPrintf(_T("other (unknown)")); break;
3195         }
3196
3197         wxPrintf(_T(", value = "));
3198         if ( key.IsNumericValue(value) )
3199         {
3200             long val;
3201             key.QueryValue(value, &val);
3202             wxPrintf(_T("%ld"), val);
3203         }
3204         else // string
3205         {
3206             wxString val;
3207             key.QueryValue(value, val);
3208             wxPrintf(_T("'%s'"), val.c_str());
3209
3210             key.QueryRawValue(value, val);
3211             wxPrintf(_T(" (raw value '%s')"), val.c_str());
3212         }
3213
3214         putchar('\n');
3215
3216         cont = key.GetNextValue(value, dummy);
3217     }
3218 }
3219
3220 static void TestRegistryAssociation()
3221 {
3222     /*
3223        The second call to deleteself genertaes an error message, with a
3224        messagebox saying .flo is crucial to system operation, while the .ddf
3225        call also fails, but with no error message
3226     */
3227
3228     wxRegKey key;
3229
3230     key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
3231     key.Create();
3232     key = _T("ddxf_auto_file") ;
3233     key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
3234     key.Create();
3235     key = _T("ddxf_auto_file") ;
3236     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
3237     key.Create();
3238     key = _T("program,0") ;
3239     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
3240     key.Create();
3241     key = _T("program \"%1\"") ;
3242
3243     key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
3244     key.DeleteSelf();
3245     key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
3246     key.DeleteSelf();
3247     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
3248     key.DeleteSelf();
3249     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
3250     key.DeleteSelf();
3251 }
3252
3253 #endif // TEST_REGISTRY
3254
3255 // ----------------------------------------------------------------------------
3256 // scope guard
3257 // ----------------------------------------------------------------------------
3258
3259 #ifdef TEST_SCOPEGUARD
3260
3261 #include "wx/scopeguard.h"
3262
3263 static void function0() { puts("function0()"); }
3264 static void function1(int n) { printf("function1(%d)\n", n); }
3265 static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
3266
3267 struct Object
3268 {
3269     void method0() { printf("method0()\n"); }
3270     void method1(int n) { printf("method1(%d)\n", n); }
3271     void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
3272 };
3273
3274 static void TestScopeGuard()
3275 {
3276     ON_BLOCK_EXIT0(function0);
3277     ON_BLOCK_EXIT1(function1, 17);
3278     ON_BLOCK_EXIT2(function2, 3.14, 'p');
3279
3280     Object obj;
3281     ON_BLOCK_EXIT_OBJ0(obj, &Object::method0);
3282     ON_BLOCK_EXIT_OBJ1(obj, &Object::method1, 7);
3283     ON_BLOCK_EXIT_OBJ2(obj, &Object::method2, 2.71, 'e');
3284
3285     wxScopeGuard dismissed = wxMakeGuard(function0);
3286     dismissed.Dismiss();
3287 }
3288
3289 #endif
3290
3291 // ----------------------------------------------------------------------------
3292 // sockets
3293 // ----------------------------------------------------------------------------
3294
3295 #ifdef TEST_SOCKETS
3296
3297 #include "wx/socket.h"
3298 #include "wx/protocol/protocol.h"
3299 #include "wx/protocol/http.h"
3300
3301 static void TestSocketServer()
3302 {
3303     wxPuts(_T("*** Testing wxSocketServer ***\n"));
3304
3305     static const int PORT = 3000;
3306
3307     wxIPV4address addr;
3308     addr.Service(PORT);
3309
3310     wxSocketServer *server = new wxSocketServer(addr);
3311     if ( !server->Ok() )
3312     {
3313         wxPuts(_T("ERROR: failed to bind"));
3314
3315         return;
3316     }
3317
3318     bool quit = false;
3319     while ( !quit )
3320     {
3321         wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
3322
3323         wxSocketBase *socket = server->Accept();
3324         if ( !socket )
3325         {
3326             wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
3327             break;
3328         }
3329
3330         wxPuts(_T("Server: got a client."));
3331
3332         server->SetTimeout(60); // 1 min
3333
3334         bool close = false;
3335         while ( !close && socket->IsConnected() )
3336         {
3337             wxString s;
3338             wxChar ch = _T('\0');
3339             for ( ;; )
3340             {
3341                 if ( socket->Read(&ch, sizeof(ch)).Error() )
3342                 {
3343                     // don't log error if the client just close the connection
3344                     if ( socket->IsConnected() )
3345                     {
3346                         wxPuts(_T("ERROR: in wxSocket::Read."));
3347                     }
3348
3349                     break;
3350                 }
3351
3352                 if ( ch == '\r' )
3353                     continue;
3354
3355                 if ( ch == '\n' )
3356                     break;
3357
3358                 s += ch;
3359             }
3360
3361             if ( ch != '\n' )
3362             {
3363                 break;
3364             }
3365
3366             wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
3367             if ( s == _T("close") )
3368             {
3369                 wxPuts(_T("Closing connection"));
3370
3371                 close = true;
3372             }
3373             else if ( s == _T("quit") )
3374             {
3375                 close =
3376                 quit = true;
3377
3378                 wxPuts(_T("Shutting down the server"));
3379             }
3380             else // not a special command
3381             {
3382                 socket->Write(s.MakeUpper().c_str(), s.length());
3383                 socket->Write("\r\n", 2);
3384                 wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
3385             }
3386         }
3387
3388         if ( !close )
3389         {
3390             wxPuts(_T("Server: lost a client unexpectedly."));
3391         }
3392
3393         socket->Destroy();
3394     }
3395
3396     // same as "delete server" but is consistent with GUI programs
3397     server->Destroy();
3398 }
3399
3400 static void TestSocketClient()
3401 {
3402     wxPuts(_T("*** Testing wxSocketClient ***\n"));
3403
3404     static const wxChar *hostname = _T("www.wxwindows.org");
3405
3406     wxIPV4address addr;
3407     addr.Hostname(hostname);
3408     addr.Service(80);
3409
3410     wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
3411
3412     wxSocketClient client;
3413     if ( !client.Connect(addr) )
3414     {
3415         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
3416     }
3417     else
3418     {
3419         wxPrintf(_T("--- Connected to %s:%u...\n"),
3420                addr.Hostname().c_str(), addr.Service());
3421
3422         wxChar buf[8192];
3423
3424         // could use simply "GET" here I suppose
3425         wxString cmdGet =
3426             wxString::Format(_T("GET http://%s/\r\n"), hostname);
3427         client.Write(cmdGet, cmdGet.length());
3428         wxPrintf(_T("--- Sent command '%s' to the server\n"),
3429                MakePrintable(cmdGet).c_str());
3430         client.Read(buf, WXSIZEOF(buf));
3431         wxPrintf(_T("--- Server replied:\n%s"), buf);
3432     }
3433 }
3434
3435 #endif // TEST_SOCKETS
3436
3437 // ----------------------------------------------------------------------------
3438 // FTP
3439 // ----------------------------------------------------------------------------
3440
3441 #ifdef TEST_FTP
3442
3443 #include "wx/protocol/ftp.h"
3444
3445 static wxFTP ftp;
3446
3447 #define FTP_ANONYMOUS
3448
3449 #ifdef FTP_ANONYMOUS
3450     static const wxChar *directory = _T("/pub");
3451     static const wxChar *filename = _T("welcome.msg");
3452 #else
3453     static const wxChar *directory = _T("/etc");
3454     static const wxChar *filename = _T("issue");
3455 #endif
3456
3457 static bool TestFtpConnect()
3458 {
3459     wxPuts(_T("*** Testing FTP connect ***"));
3460
3461 #ifdef FTP_ANONYMOUS
3462     static const wxChar *hostname = _T("ftp.wxwindows.org");
3463
3464     wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
3465 #else // !FTP_ANONYMOUS
3466     static const wxChar *hostname = "localhost";
3467
3468     wxChar user[256];
3469     wxFgets(user, WXSIZEOF(user), stdin);
3470     user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
3471     ftp.SetUser(user);
3472
3473     wxChar password[256];
3474     wxPrintf(_T("Password for %s: "), password);
3475     wxFgets(password, WXSIZEOF(password), stdin);
3476     password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
3477     ftp.SetPassword(password);
3478
3479     wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
3480 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
3481
3482     if ( !ftp.Connect(hostname) )
3483     {
3484         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
3485
3486         return false;
3487     }
3488     else
3489     {
3490         wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
3491                hostname, ftp.Pwd().c_str());
3492     }
3493
3494     return true;
3495 }
3496
3497 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
3498 static void TestFtpWuFtpd()
3499 {
3500     wxFTP ftp;
3501     static const wxChar *hostname = _T("ftp.eudora.com");
3502     if ( !ftp.Connect(hostname) )
3503     {
3504         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
3505     }
3506     else
3507     {
3508         static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
3509         wxInputStream *in = ftp.GetInputStream(filename);
3510         if ( !in )
3511         {
3512             wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
3513         }
3514         else
3515         {
3516             size_t size = in->GetSize();
3517             wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
3518
3519             wxChar *data = new wxChar[size];
3520             if ( !in->Read(data, size) )
3521             {
3522                 wxPuts(_T("ERROR: read error"));
3523             }
3524             else
3525             {
3526                 wxPrintf(_T("Successfully retrieved the file.\n"));
3527             }
3528
3529             delete [] data;
3530             delete in;
3531         }
3532     }
3533 }
3534
3535 static void TestFtpList()
3536 {
3537     wxPuts(_T("*** Testing wxFTP file listing ***\n"));
3538
3539     // test CWD
3540     if ( !ftp.ChDir(directory) )
3541     {
3542         wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
3543     }
3544
3545     wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
3546
3547     // test NLIST and LIST
3548     wxArrayString files;
3549     if ( !ftp.GetFilesList(files) )
3550     {
3551         wxPuts(_T("ERROR: failed to get NLIST of files"));
3552     }
3553     else
3554     {
3555         wxPrintf(_T("Brief list of files under '%s':\n"), ftp.Pwd().c_str());
3556         size_t count = files.GetCount();
3557         for ( size_t n = 0; n < count; n++ )
3558         {
3559             wxPrintf(_T("\t%s\n"), files[n].c_str());
3560         }
3561         wxPuts(_T("End of the file list"));
3562     }
3563
3564     if ( !ftp.GetDirList(files) )
3565     {
3566         wxPuts(_T("ERROR: failed to get LIST of files"));
3567     }
3568     else
3569     {
3570         wxPrintf(_T("Detailed list of files under '%s':\n"), ftp.Pwd().c_str());
3571         size_t count = files.GetCount();
3572         for ( size_t n = 0; n < count; n++ )
3573         {
3574             wxPrintf(_T("\t%s\n"), files[n].c_str());
3575         }
3576         wxPuts(_T("End of the file list"));
3577     }
3578
3579     if ( !ftp.ChDir(_T("..")) )
3580     {
3581         wxPuts(_T("ERROR: failed to cd to .."));
3582     }
3583
3584     wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
3585 }
3586
3587 static void TestFtpDownload()
3588 {
3589     wxPuts(_T("*** Testing wxFTP download ***\n"));
3590
3591     // test RETR
3592     wxInputStream *in = ftp.GetInputStream(filename);
3593     if ( !in )
3594     {
3595         wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
3596     }
3597     else
3598     {
3599         size_t size = in->GetSize();
3600         wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
3601         fflush(stdout);
3602
3603         wxChar *data = new wxChar[size];
3604         if ( !in->Read(data, size) )
3605         {
3606             wxPuts(_T("ERROR: read error"));
3607         }
3608         else
3609         {
3610             wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
3611         }
3612
3613         delete [] data;
3614         delete in;
3615     }
3616 }
3617
3618 static void TestFtpFileSize()
3619 {
3620     wxPuts(_T("*** Testing FTP SIZE command ***"));
3621
3622     if ( !ftp.ChDir(directory) )
3623     {
3624         wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
3625     }
3626
3627     wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
3628
3629     if ( ftp.FileExists(filename) )
3630     {
3631         int size = ftp.GetFileSize(filename);
3632         if ( size == -1 )
3633             wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
3634         else
3635             wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
3636     }
3637     else
3638     {
3639         wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
3640     }
3641 }
3642
3643 static void TestFtpMisc()
3644 {
3645     wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
3646
3647     if ( ftp.SendCommand(_T("STAT")) != '2' )
3648     {
3649         wxPuts(_T("ERROR: STAT failed"));
3650     }
3651     else
3652     {
3653         wxPrintf(_T("STAT returned:\n\n%s\n"), ftp.GetLastResult().c_str());
3654     }
3655
3656     if ( ftp.SendCommand(_T("HELP SITE")) != '2' )
3657     {
3658         wxPuts(_T("ERROR: HELP SITE failed"));
3659     }
3660     else
3661     {
3662         wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
3663                ftp.GetLastResult().c_str());
3664     }
3665 }
3666
3667 static void TestFtpInteractive()
3668 {
3669     wxPuts(_T("\n*** Interactive wxFTP test ***"));
3670
3671     wxChar buf[128];
3672
3673     for ( ;; )
3674     {
3675         wxPrintf(_T("Enter FTP command: "));
3676         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
3677             break;
3678
3679         // kill the last '\n'
3680         buf[wxStrlen(buf) - 1] = 0;
3681
3682         // special handling of LIST and NLST as they require data connection
3683         wxString start(buf, 4);
3684         start.MakeUpper();
3685         if ( start == _T("LIST") || start == _T("NLST") )
3686         {
3687             wxString wildcard;
3688             if ( wxStrlen(buf) > 4 )
3689                 wildcard = buf + 5;
3690
3691             wxArrayString files;
3692             if ( !ftp.GetList(files, wildcard, start == _T("LIST")) )
3693             {
3694                 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
3695             }
3696             else
3697             {
3698                 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
3699                        start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
3700                 size_t count = files.GetCount();
3701                 for ( size_t n = 0; n < count; n++ )
3702                 {
3703                     wxPrintf(_T("\t%s\n"), files[n].c_str());
3704                 }
3705                 wxPuts(_T("--- End of the file list"));
3706             }
3707         }
3708         else // !list
3709         {
3710             wxChar ch = ftp.SendCommand(buf);
3711             wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
3712             if ( ch )
3713             {
3714                 wxPrintf(_T(" (return code %c)"), ch);
3715             }
3716
3717             wxPrintf(_T(", server reply:\n%s\n\n"), ftp.GetLastResult().c_str());
3718         }
3719     }
3720
3721     wxPuts(_T("\n*** done ***"));
3722 }
3723
3724 static void TestFtpUpload()
3725 {
3726     wxPuts(_T("*** Testing wxFTP uploading ***\n"));
3727
3728     // upload a file
3729     static const wxChar *file1 = _T("test1");
3730     static const wxChar *file2 = _T("test2");
3731     wxOutputStream *out = ftp.GetOutputStream(file1);
3732     if ( out )
3733     {
3734         wxPrintf(_T("--- Uploading to %s ---\n"), file1);
3735         out->Write("First hello", 11);
3736         delete out;
3737     }
3738
3739     // send a command to check the remote file
3740     if ( ftp.SendCommand(wxString(_T("STAT ")) + file1) != '2' )
3741     {
3742         wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
3743     }
3744     else
3745     {
3746         wxPrintf(_T("STAT %s returned:\n\n%s\n"),
3747                file1, ftp.GetLastResult().c_str());
3748     }
3749
3750     out = ftp.GetOutputStream(file2);
3751     if ( out )
3752     {
3753         wxPrintf(_T("--- Uploading to %s ---\n"), file1);
3754         out->Write("Second hello", 12);
3755         delete out;
3756     }
3757 }
3758
3759 #endif // TEST_FTP
3760
3761 // ----------------------------------------------------------------------------
3762 // streams
3763 // ----------------------------------------------------------------------------
3764
3765 #ifdef TEST_STREAMS
3766
3767 #include "wx/wfstream.h"
3768 #include "wx/mstream.h"
3769
3770 static void TestFileStream()
3771 {
3772     wxPuts(_T("*** Testing wxFileInputStream ***"));
3773
3774     static const wxChar *filename = _T("testdata.fs");
3775     {
3776         wxFileOutputStream fsOut(filename);
3777         fsOut.Write("foo", 3);
3778     }
3779
3780     wxFileInputStream fsIn(filename);
3781     wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
3782     while ( !fsIn.Eof() )
3783     {
3784         putchar(fsIn.GetC());
3785     }
3786
3787     if ( !wxRemoveFile(filename) )
3788     {
3789         wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename);
3790     }
3791
3792     wxPuts(_T("\n*** wxFileInputStream test done ***"));
3793 }
3794
3795 static void TestMemoryStream()
3796 {
3797     wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
3798
3799     wxMemoryOutputStream memOutStream;
3800     wxPrintf(_T("Initially out stream offset: %lu\n"),
3801              (unsigned long)memOutStream.TellO());
3802
3803     for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
3804     {
3805         memOutStream.PutC(*p);
3806     }
3807
3808     wxPrintf(_T("Final out stream offset: %lu\n"),
3809              (unsigned long)memOutStream.TellO());
3810
3811     wxPuts(_T("*** Testing wxMemoryInputStream ***"));
3812
3813     wxChar buf[1024];
3814     size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
3815
3816     wxMemoryInputStream memInpStream(buf, len);
3817     wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
3818     while ( !memInpStream.Eof() )
3819     {
3820         putchar(memInpStream.GetC());
3821     }
3822
3823     wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
3824 }
3825
3826 #endif // TEST_STREAMS
3827
3828 // ----------------------------------------------------------------------------
3829 // timers
3830 // ----------------------------------------------------------------------------
3831
3832 #ifdef TEST_TIMER
3833
3834 #include "wx/timer.h"
3835 #include "wx/utils.h"
3836
3837 static void TestStopWatch()
3838 {
3839     wxPuts(_T("*** Testing wxStopWatch ***\n"));
3840
3841     wxStopWatch sw;
3842     sw.Pause();
3843     wxPrintf(_T("Initially paused, after 2 seconds time is..."));
3844     fflush(stdout);
3845     wxSleep(2);
3846     wxPrintf(_T("\t%ldms\n"), sw.Time());
3847
3848     wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
3849     fflush(stdout);
3850     sw.Resume();
3851     wxSleep(3);
3852     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3853
3854     sw.Pause();
3855     wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
3856     fflush(stdout);
3857     wxSleep(2);
3858     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3859
3860     sw.Resume();
3861     wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
3862     fflush(stdout);
3863     wxSleep(2);
3864     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3865
3866     wxStopWatch sw2;
3867     wxPuts(_T("\nChecking for 'backwards clock' bug..."));
3868     for ( size_t n = 0; n < 70; n++ )
3869     {
3870         sw2.Start();
3871
3872         for ( size_t m = 0; m < 100000; m++ )
3873         {
3874             if ( sw.Time() < 0 || sw2.Time() < 0 )
3875             {
3876                 wxPuts(_T("\ntime is negative - ERROR!"));
3877             }
3878         }
3879
3880         putchar('.');
3881         fflush(stdout);
3882     }
3883
3884     wxPuts(_T(", ok."));
3885 }
3886
3887 #endif // TEST_TIMER
3888
3889 // ----------------------------------------------------------------------------
3890 // vCard support
3891 // ----------------------------------------------------------------------------
3892
3893 #ifdef TEST_VCARD
3894
3895 #include "wx/vcard.h"
3896
3897 static void DumpVObject(size_t level, const wxVCardObject& vcard)
3898 {
3899     void *cookie;
3900     wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3901     while ( vcObj )
3902     {
3903         wxPrintf(_T("%s%s"),
3904                wxString(_T('\t'), level).c_str(),
3905                vcObj->GetName().c_str());
3906
3907         wxString value;
3908         switch ( vcObj->GetType() )
3909         {
3910             case wxVCardObject::String:
3911             case wxVCardObject::UString:
3912                 {
3913                     wxString val;
3914                     vcObj->GetValue(&val);
3915                     value << _T('"') << val << _T('"');
3916                 }
3917                 break;
3918
3919             case wxVCardObject::Int:
3920                 {
3921                     unsigned int i;
3922                     vcObj->GetValue(&i);
3923                     value.Printf(_T("%u"), i);
3924                 }
3925                 break;
3926
3927             case wxVCardObject::Long:
3928                 {
3929                     unsigned long l;
3930                     vcObj->GetValue(&l);
3931                     value.Printf(_T("%lu"), l);
3932                 }
3933                 break;
3934
3935             case wxVCardObject::None:
3936                 break;
3937
3938             case wxVCardObject::Object:
3939                 value = _T("<node>");
3940                 break;
3941
3942             default:
3943                 value = _T("<unknown value type>");
3944         }
3945
3946         if ( !!value )
3947             wxPrintf(_T(" = %s"), value.c_str());
3948         putchar('\n');
3949
3950         DumpVObject(level + 1, *vcObj);
3951
3952         delete vcObj;
3953         vcObj = vcard.GetNextProp(&cookie);
3954     }
3955 }
3956
3957 static void DumpVCardAddresses(const wxVCard& vcard)
3958 {
3959     wxPuts(_T("\nShowing all addresses from vCard:\n"));
3960
3961     size_t nAdr = 0;
3962     void *cookie;
3963     wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3964     while ( addr )
3965     {
3966         wxString flagsStr;
3967         int flags = addr->GetFlags();
3968         if ( flags & wxVCardAddress::Domestic )
3969         {
3970             flagsStr << _T("domestic ");
3971         }
3972         if ( flags & wxVCardAddress::Intl )
3973         {
3974             flagsStr << _T("international ");
3975         }
3976         if ( flags & wxVCardAddress::Postal )
3977         {
3978             flagsStr << _T("postal ");
3979         }
3980         if ( flags & wxVCardAddress::Parcel )
3981         {
3982             flagsStr << _T("parcel ");
3983         }
3984         if ( flags & wxVCardAddress::Home )
3985         {
3986             flagsStr << _T("home ");
3987         }
3988         if ( flags & wxVCardAddress::Work )
3989         {
3990             flagsStr << _T("work ");
3991         }
3992
3993         wxPrintf(_T("Address %u:\n")
3994                "\tflags = %s\n"
3995                "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3996                ++nAdr,
3997                flagsStr.c_str(),
3998                addr->GetPostOffice().c_str(),
3999                addr->GetExtAddress().c_str(),
4000                addr->GetStreet().c_str(),
4001                addr->GetLocality().c_str(),
4002                addr->GetRegion().c_str(),
4003                addr->GetPostalCode().c_str(),
4004                addr->GetCountry().c_str()
4005                );
4006
4007         delete addr;
4008         addr = vcard.GetNextAddress(&cookie);
4009     }
4010 }
4011
4012 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
4013 {
4014     wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
4015
4016     size_t nPhone = 0;
4017     void *cookie;
4018     wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
4019     while ( phone )
4020     {
4021         wxString flagsStr;
4022         int flags = phone->GetFlags();
4023         if ( flags & wxVCardPhoneNumber::Voice )
4024         {
4025             flagsStr << _T("voice ");
4026         }
4027         if ( flags & wxVCardPhoneNumber::Fax )
4028         {
4029             flagsStr << _T("fax ");
4030         }
4031         if ( flags & wxVCardPhoneNumber::Cellular )
4032         {
4033             flagsStr << _T("cellular ");
4034         }
4035         if ( flags & wxVCardPhoneNumber::Modem )
4036         {
4037             flagsStr << _T("modem ");
4038         }
4039         if ( flags & wxVCardPhoneNumber::Home )
4040         {
4041             flagsStr << _T("home ");
4042         }
4043         if ( flags & wxVCardPhoneNumber::Work )
4044         {
4045             flagsStr << _T("work ");
4046         }
4047
4048         wxPrintf(_T("Phone number %u:\n")
4049                "\tflags = %s\n"
4050                "\tvalue = %s\n",
4051                ++nPhone,
4052                flagsStr.c_str(),
4053                phone->GetNumber().c_str()
4054                );
4055
4056         delete phone;
4057         phone = vcard.GetNextPhoneNumber(&cookie);
4058     }
4059 }
4060
4061 static void TestVCardRead()
4062 {
4063     wxPuts(_T("*** Testing wxVCard reading ***\n"));
4064
4065     wxVCard vcard(_T("vcard.vcf"));
4066     if ( !vcard.IsOk() )
4067     {
4068         wxPuts(_T("ERROR: couldn't load vCard."));
4069     }
4070     else
4071     {
4072         // read individual vCard properties
4073         wxVCardObject *vcObj = vcard.GetProperty("FN");
4074         wxString value;
4075         if ( vcObj )
4076         {
4077             vcObj->GetValue(&value);
4078             delete vcObj;
4079         }
4080         else
4081         {
4082             value = _T("<none>");
4083         }
4084
4085         wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
4086
4087
4088         if ( !vcard.GetFullName(&value) )
4089         {
4090             value = _T("<none>");
4091         }
4092
4093         wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
4094
4095         // now show how to deal with multiply occuring properties
4096         DumpVCardAddresses(vcard);
4097         DumpVCardPhoneNumbers(vcard);
4098
4099         // and finally show all
4100         wxPuts(_T("\nNow dumping the entire vCard:\n")
4101              "-----------------------------\n");
4102
4103         DumpVObject(0, vcard);
4104     }
4105 }
4106
4107 static void TestVCardWrite()
4108 {
4109     wxPuts(_T("*** Testing wxVCard writing ***\n"));
4110
4111     wxVCard vcard;
4112     if ( !vcard.IsOk() )
4113     {
4114         wxPuts(_T("ERROR: couldn't create vCard."));
4115     }
4116     else
4117     {
4118         // set some fields
4119         vcard.SetName("Zeitlin", "Vadim");
4120         vcard.SetFullName("Vadim Zeitlin");
4121         vcard.SetOrganization("wxWindows", "R&D");
4122
4123         // just dump the vCard back
4124         wxPuts(_T("Entire vCard follows:\n"));
4125         wxPuts(vcard.Write());
4126     }
4127 }
4128
4129 #endif // TEST_VCARD
4130
4131 // ----------------------------------------------------------------------------
4132 // wxVolume tests
4133 // ----------------------------------------------------------------------------
4134
4135 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
4136     #undef TEST_VOLUME
4137 #endif
4138
4139 #ifdef TEST_VOLUME
4140
4141 #include "wx/volume.h"
4142
4143 static const wxChar *volumeKinds[] =
4144 {
4145     _T("floppy"),
4146     _T("hard disk"),
4147     _T("CD-ROM"),
4148     _T("DVD-ROM"),
4149     _T("network volume"),
4150     _T("other volume"),
4151 };
4152
4153 static void TestFSVolume()
4154 {
4155     wxPuts(_T("*** Testing wxFSVolume class ***"));
4156
4157     wxArrayString volumes = wxFSVolume::GetVolumes();
4158     size_t count = volumes.GetCount();
4159
4160     if ( !count )
4161     {
4162         wxPuts(_T("ERROR: no mounted volumes?"));
4163         return;
4164     }
4165
4166     wxPrintf(_T("%u mounted volumes found:\n"), count);
4167
4168     for ( size_t n = 0; n < count; n++ )
4169     {
4170         wxFSVolume vol(volumes[n]);
4171         if ( !vol.IsOk() )
4172         {
4173             wxPuts(_T("ERROR: couldn't create volume"));
4174             continue;
4175         }
4176
4177         wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
4178                  n + 1,
4179                  vol.GetDisplayName().c_str(),
4180                  vol.GetName().c_str(),
4181                  volumeKinds[vol.GetKind()],
4182                  vol.IsWritable() ? _T("rw") : _T("ro"),
4183                  vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
4184                                                      : _T("fixed"));
4185     }
4186 }
4187
4188 #endif // TEST_VOLUME
4189
4190 // ----------------------------------------------------------------------------
4191 // wide char and Unicode support
4192 // ----------------------------------------------------------------------------
4193
4194 #ifdef TEST_UNICODE
4195
4196 static void TestUnicodeToFromAscii()
4197 {
4198     wxPuts(_T("Testing wxString::To/FromAscii()\n"));
4199
4200     static const char *msg = "Hello, world!";
4201     wxString s = wxString::FromAscii(msg);
4202
4203     wxPrintf(_T("Message in Unicode: %s\n"), s.c_str());
4204     printf("Message in ASCII: %s\n", (const char *)s.ToAscii());
4205
4206     wxPutchar(_T('\n'));
4207 }
4208
4209 #endif // TEST_UNICODE
4210
4211 #ifdef TEST_WCHAR
4212
4213 #include "wx/strconv.h"
4214 #include "wx/fontenc.h"
4215 #include "wx/encconv.h"
4216 #include "wx/buffer.h"
4217
4218 static const unsigned char utf8koi8r[] =
4219 {
4220     208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
4221     208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
4222     176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
4223     208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
4224     181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
4225     208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
4226     178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
4227 };
4228
4229 static const unsigned char utf8iso8859_1[] =
4230 {
4231     0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
4232     0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
4233     0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
4234     0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
4235     0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
4236 };
4237
4238 static const unsigned char utf8Invalid[] =
4239 {
4240     0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
4241     0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
4242     0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
4243     0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
4244     0x6c, 0x61, 0x79, 0
4245 };
4246
4247 static const struct Utf8Data
4248 {
4249     const unsigned char *text;
4250     size_t len;
4251     const wxChar *charset;
4252     wxFontEncoding encoding;
4253 } utf8data[] =
4254 {
4255     { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
4256     { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
4257     { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
4258 };
4259
4260 static void TestUtf8()
4261 {
4262     wxPuts(_T("*** Testing UTF8 support ***\n"));
4263
4264     char buf[1024];
4265     wchar_t wbuf[1024];
4266
4267     for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
4268     {
4269         const Utf8Data& u8d = utf8data[n];
4270         if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
4271                               WXSIZEOF(wbuf)) == (size_t)-1 )
4272         {
4273             wxPuts(_T("ERROR: UTF-8 decoding failed."));
4274         }
4275         else
4276         {
4277             wxCSConv conv(u8d.charset);
4278             if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
4279             {
4280                 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
4281             }
4282             else
4283             {
4284                 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
4285             }
4286         }
4287
4288         wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text), *wxConvCurrent);
4289         if ( s.empty() )
4290             s = _T("<< conversion failed >>");
4291         wxPrintf(_T("String in current cset: %s\n"), s.c_str());
4292
4293     }
4294
4295     wxPuts(_T(""));
4296 }
4297
4298 static void TestEncodingConverter()
4299 {
4300     wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
4301
4302     // using wxEncodingConverter should give the same result as above
4303     char buf[1024];
4304     wchar_t wbuf[1024];
4305     if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
4306                           WXSIZEOF(utf8koi8r)) == (size_t)-1 )
4307     {
4308         wxPuts(_T("ERROR: UTF-8 decoding failed."));
4309     }
4310     else
4311     {
4312         wxEncodingConverter ec;
4313         ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
4314         ec.Convert(wbuf, buf);
4315         wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
4316     }
4317
4318     wxPuts(_T(""));
4319 }
4320
4321 #endif // TEST_WCHAR
4322
4323 // ----------------------------------------------------------------------------
4324 // ZIP stream
4325 // ----------------------------------------------------------------------------
4326
4327 #ifdef TEST_ZIP
4328
4329 #include "wx/filesys.h"
4330 #include "wx/fs_zip.h"
4331 #include "wx/zipstrm.h"
4332
4333 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
4334
4335 static void TestZipStreamRead()
4336 {
4337     wxPuts(_T("*** Testing ZIP reading ***\n"));
4338
4339     static const wxChar *filename = _T("foo");
4340     wxZipInputStream istr(TESTFILE_ZIP, filename);
4341     wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
4342
4343     wxPrintf(_T("Dumping the file '%s':\n"), filename);
4344     while ( !istr.Eof() )
4345     {
4346         putchar(istr.GetC());
4347         fflush(stdout);
4348     }
4349
4350     wxPuts(_T("\n----- done ------"));
4351 }
4352
4353 static void DumpZipDirectory(wxFileSystem& fs,
4354                              const wxString& dir,
4355                              const wxString& indent)
4356 {
4357     wxString prefix = wxString::Format(_T("%s#zip:%s"),
4358                                          TESTFILE_ZIP, dir.c_str());
4359     wxString wildcard = prefix + _T("/*");
4360
4361     wxString dirname = fs.FindFirst(wildcard, wxDIR);
4362     while ( !dirname.empty() )
4363     {
4364         if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
4365         {
4366             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
4367
4368             break;
4369         }
4370
4371         wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
4372
4373         DumpZipDirectory(fs, dirname,
4374                          indent + wxString(_T(' '), 4));
4375
4376         dirname = fs.FindNext();
4377     }
4378
4379     wxString filename = fs.FindFirst(wildcard, wxFILE);
4380     while ( !filename.empty() )
4381     {
4382         if ( !filename.StartsWith(prefix, &filename) )
4383         {
4384             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
4385
4386             break;
4387         }
4388
4389         wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
4390
4391         filename = fs.FindNext();
4392     }
4393 }
4394
4395 static void TestZipFileSystem()
4396 {
4397     wxPuts(_T("*** Testing ZIP file system ***\n"));
4398
4399     wxFileSystem::AddHandler(new wxZipFSHandler);
4400     wxFileSystem fs;
4401     wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
4402
4403     DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
4404 }
4405
4406 #endif // TEST_ZIP
4407
4408 // ----------------------------------------------------------------------------
4409 // ZLIB stream
4410 // ----------------------------------------------------------------------------
4411
4412 #ifdef TEST_ZLIB
4413
4414 #include "wx/zstream.h"
4415 #include "wx/wfstream.h"
4416
4417 static const wxChar *FILENAME_GZ = _T("test.gz");
4418 static const wxChar *TEST_DATA = _T("hello and hello and hello and hello and hello");
4419
4420 static void TestZlibStreamWrite()
4421 {
4422     wxPuts(_T("*** Testing Zlib stream reading ***\n"));
4423
4424     wxFileOutputStream fileOutStream(FILENAME_GZ);
4425     wxZlibOutputStream ostr(fileOutStream);
4426     wxPrintf(_T("Compressing the test string... "));
4427     ostr.Write(TEST_DATA, wxStrlen(TEST_DATA) + 1);
4428     if ( !ostr )
4429     {
4430         wxPuts(_T("(ERROR: failed)"));
4431     }
4432     else
4433     {
4434         wxPuts(_T("(ok)"));
4435     }
4436
4437     wxPuts(_T("\n----- done ------"));
4438 }
4439
4440 static void TestZlibStreamRead()
4441 {
4442     wxPuts(_T("*** Testing Zlib stream reading ***\n"));
4443
4444     wxFileInputStream fileInStream(FILENAME_GZ);
4445     wxZlibInputStream istr(fileInStream);
4446     wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
4447
4448     wxPuts(_T("Dumping the file:"));
4449     while ( !istr.Eof() )
4450     {
4451         putchar(istr.GetC());
4452         fflush(stdout);
4453     }
4454
4455     wxPuts(_T("\n----- done ------"));
4456 }
4457
4458 #endif // TEST_ZLIB
4459
4460 // ----------------------------------------------------------------------------
4461 // date time
4462 // ----------------------------------------------------------------------------
4463
4464 #ifdef TEST_DATETIME
4465
4466 #include <math.h>
4467
4468 #include "wx/datetime.h"
4469
4470 // the test data
4471 struct Date
4472 {
4473     wxDateTime::wxDateTime_t day;
4474     wxDateTime::Month month;
4475     int year;
4476     wxDateTime::wxDateTime_t hour, min, sec;
4477     double jdn;
4478     wxDateTime::WeekDay wday;
4479     time_t gmticks, ticks;
4480
4481     void Init(const wxDateTime::Tm& tm)
4482     {
4483         day = tm.mday;
4484         month = tm.mon;
4485         year = tm.year;
4486         hour = tm.hour;
4487         min = tm.min;
4488         sec = tm.sec;
4489         jdn = 0.0;
4490         gmticks = ticks = -1;
4491     }
4492
4493     wxDateTime DT() const
4494         { return wxDateTime(day, month, year, hour, min, sec); }
4495
4496     bool SameDay(const wxDateTime::Tm& tm) const
4497     {
4498         return day == tm.mday && month == tm.mon && year == tm.year;
4499     }
4500
4501     wxString Format() const
4502     {
4503         wxString s;
4504         s.Printf(_T("%02d:%02d:%02d %10s %02d, %4d%s"),
4505                  hour, min, sec,
4506                  wxDateTime::GetMonthName(month).c_str(),
4507                  day,
4508                  abs(wxDateTime::ConvertYearToBC(year)),
4509                  year > 0 ? _T("AD") : _T("BC"));
4510         return s;
4511     }
4512
4513     wxString FormatDate() const
4514     {
4515         wxString s;
4516         s.Printf(_T("%02d-%s-%4d%s"),
4517                  day,
4518                  wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
4519                  abs(wxDateTime::ConvertYearToBC(year)),
4520                  year > 0 ? _T("AD") : _T("BC"));
4521         return s;
4522     }
4523 };
4524
4525 static const Date testDates[] =
4526 {
4527     {  1, wxDateTime::Jan,  1970, 00, 00, 00, 2440587.5, wxDateTime::Thu,         0,     -3600 },
4528     {  7, wxDateTime::Feb,  2036, 00, 00, 00, 2464730.5, wxDateTime::Thu,        -1,        -1 },
4529     {  8, wxDateTime::Feb,  2036, 00, 00, 00, 2464731.5, wxDateTime::Fri,        -1,        -1 },
4530     {  1, wxDateTime::Jan,  2037, 00, 00, 00, 2465059.5, wxDateTime::Thu,        -1,        -1 },
4531     {  1, wxDateTime::Jan,  2038, 00, 00, 00, 2465424.5, wxDateTime::Fri,        -1,        -1 },
4532     { 21, wxDateTime::Jan,  2222, 00, 00, 00, 2532648.5, wxDateTime::Mon,        -1,        -1 },
4533     { 29, wxDateTime::May,  1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
4534     { 29, wxDateTime::Feb,  1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
4535     {  1, wxDateTime::Jan,  1900, 12, 00, 00, 2415021.0, wxDateTime::Mon,        -1,        -1 },
4536     {  1, wxDateTime::Jan,  1900, 00, 00, 00, 2415020.5, wxDateTime::Mon,        -1,        -1 },
4537     { 15, wxDateTime::Oct,  1582, 00, 00, 00, 2299160.5, wxDateTime::Fri,        -1,        -1 },
4538     {  4, wxDateTime::Oct,  1582, 00, 00, 00, 2299149.5, wxDateTime::Mon,        -1,        -1 },
4539     {  1, wxDateTime::Mar,     1, 00, 00, 00, 1721484.5, wxDateTime::Thu,        -1,        -1 },
4540     {  1, wxDateTime::Jan,     1, 00, 00, 00, 1721425.5, wxDateTime::Mon,        -1,        -1 },
4541     { 31, wxDateTime::Dec,     0, 00, 00, 00, 1721424.5, wxDateTime::Sun,        -1,        -1 },
4542     {  1, wxDateTime::Jan,     0, 00, 00, 00, 1721059.5, wxDateTime::Sat,        -1,        -1 },
4543     { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri,        -1,        -1 },
4544     { 12, wxDateTime::Aug, -4000, 00, 00, 00,  260313.5, wxDateTime::Sat,        -1,        -1 },
4545     { 24, wxDateTime::Nov, -4713, 00, 00, 00,      -0.5, wxDateTime::Mon,        -1,        -1 },
4546 };
4547
4548 // this test miscellaneous static wxDateTime functions
4549 static void TestTimeStatic()
4550 {
4551     wxPuts(_T("\n*** wxDateTime static methods test ***"));
4552
4553     // some info about the current date
4554     int year = wxDateTime::GetCurrentYear();
4555     wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
4556            year,
4557            wxDateTime::IsLeapYear(year) ? "" : "not ",
4558            wxDateTime::GetNumberOfDays(year));
4559
4560     wxDateTime::Month month = wxDateTime::GetCurrentMonth();
4561     wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
4562            wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
4563            wxDateTime::GetMonthName(month).c_str(),
4564            wxDateTime::GetNumberOfDays(month));
4565
4566     // leap year logic
4567     static const size_t nYears = 5;
4568     static const size_t years[2][nYears] =
4569     {
4570         // first line: the years to test
4571         { 1990, 1976, 2000, 2030, 1984, },
4572
4573         // second line: true if leap, false otherwise
4574         { false, true, true, false, true }
4575     };
4576
4577     for ( size_t n = 0; n < nYears; n++ )
4578     {
4579         int year = years[0][n];
4580         bool should = years[1][n] != 0,
4581              is = wxDateTime::IsLeapYear(year);
4582
4583         wxPrintf(_T("Year %d is %sa leap year (%s)\n"),
4584                year,
4585                is ? "" : "not ",
4586                should == is ? "ok" : "ERROR");
4587
4588         wxASSERT( should == wxDateTime::IsLeapYear(year) );
4589     }
4590 }
4591
4592 // test constructing wxDateTime objects
4593 static void TestTimeSet()
4594 {
4595     wxPuts(_T("\n*** wxDateTime construction test ***"));
4596
4597     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4598     {
4599         const Date& d1 = testDates[n];
4600         wxDateTime dt = d1.DT();
4601
4602         Date d2;
4603         d2.Init(dt.GetTm());
4604
4605         wxString s1 = d1.Format(),
4606                  s2 = d2.Format();
4607
4608         wxPrintf(_T("Date: %s == %s (%s)\n"),
4609                  s1.c_str(), s2.c_str(),
4610                  s1 == s2 ? _T("ok") : _T("ERROR"));
4611     }
4612 }
4613
4614 // test time zones stuff
4615 static void TestTimeZones()
4616 {
4617     wxPuts(_T("\n*** wxDateTime timezone test ***"));
4618
4619     wxDateTime now = wxDateTime::Now();
4620
4621     wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
4622     wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
4623     wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
4624     wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
4625     wxPrintf(_T("               Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
4626     wxPrintf(_T("             New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
4627
4628     wxDateTime::Tm tm = now.GetTm();
4629     if ( wxDateTime(tm) != now )
4630     {
4631         wxPrintf(_T("ERROR: got %s instead of %s\n"),
4632                  wxDateTime(tm).Format().c_str(), now.Format().c_str());
4633     }
4634 }
4635
4636 // test some minimal support for the dates outside the standard range
4637 static void TestTimeRange()
4638 {
4639     wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
4640
4641     static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
4642
4643     wxPrintf(_T("Unix epoch:\t%s\n"),
4644              wxDateTime(2440587.5).Format(fmt).c_str());
4645     wxPrintf(_T("Feb 29, 0: \t%s\n"),
4646              wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
4647     wxPrintf(_T("JDN 0:     \t%s\n"),
4648              wxDateTime(0.0).Format(fmt).c_str());
4649     wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
4650              wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
4651     wxPrintf(_T("May 29, 2099:\t%s\n"),
4652              wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
4653 }
4654
4655 static void TestTimeTicks()
4656 {
4657     wxPuts(_T("\n*** wxDateTime ticks test ***"));
4658
4659     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4660     {
4661         const Date& d = testDates[n];
4662         if ( d.ticks == -1 )
4663             continue;
4664
4665         wxDateTime dt = d.DT();
4666         long ticks = (dt.GetValue() / 1000).ToLong();
4667         wxPrintf(_T("Ticks of %s:\t% 10ld"), d.Format().c_str(), ticks);
4668         if ( ticks == d.ticks )
4669         {
4670             wxPuts(_T(" (ok)"));
4671         }
4672         else
4673         {
4674             wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
4675                      (long)d.ticks, (long)(ticks - d.ticks));
4676         }
4677
4678         dt = d.DT().ToTimezone(wxDateTime::GMT0);
4679         ticks = (dt.GetValue() / 1000).ToLong();
4680         wxPrintf(_T("GMtks of %s:\t% 10ld"), d.Format().c_str(), ticks);
4681         if ( ticks == d.gmticks )
4682         {
4683             wxPuts(_T(" (ok)"));
4684         }
4685         else
4686         {
4687             wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
4688                      (long)d.gmticks, (long)(ticks - d.gmticks));
4689         }
4690     }
4691
4692     wxPuts(_T(""));
4693 }
4694
4695 // test conversions to JDN &c
4696 static void TestTimeJDN()
4697 {
4698     wxPuts(_T("\n*** wxDateTime to JDN test ***"));
4699
4700     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4701     {
4702         const Date& d = testDates[n];
4703         wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
4704         double jdn = dt.GetJulianDayNumber();
4705
4706         wxPrintf(_T("JDN of %s is:\t% 15.6f"), d.Format().c_str(), jdn);
4707         if ( jdn == d.jdn )
4708         {
4709             wxPuts(_T(" (ok)"));
4710         }
4711         else
4712         {
4713             wxPrintf(_T(" (ERROR: should be %f, delta = %f)\n"),
4714                      d.jdn, jdn - d.jdn);
4715         }
4716     }
4717 }
4718
4719 // test week days computation
4720 static void TestTimeWDays()
4721 {
4722     wxPuts(_T("\n*** wxDateTime weekday test ***"));
4723
4724     // test GetWeekDay()
4725     size_t n;
4726     for ( n = 0; n < WXSIZEOF(testDates); n++ )
4727     {
4728         const Date& d = testDates[n];
4729         wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
4730
4731         wxDateTime::WeekDay wday = dt.GetWeekDay();
4732         wxPrintf(_T("%s is: %s"),
4733                  d.Format().c_str(),
4734                  wxDateTime::GetWeekDayName(wday).c_str());
4735         if ( wday == d.wday )
4736         {
4737             wxPuts(_T(" (ok)"));
4738         }
4739         else
4740         {
4741             wxPrintf(_T(" (ERROR: should be %s)\n"),
4742                      wxDateTime::GetWeekDayName(d.wday).c_str());
4743         }
4744     }
4745
4746     wxPuts(_T(""));
4747
4748     // test SetToWeekDay()
4749     struct WeekDateTestData
4750     {
4751         Date date;                  // the real date (precomputed)
4752         int nWeek;                  // its week index in the month
4753         wxDateTime::WeekDay wday;   // the weekday
4754         wxDateTime::Month month;    // the month
4755         int year;                   // and the year
4756
4757         wxString Format() const
4758         {
4759             wxString s, which;
4760             switch ( nWeek < -1 ? -nWeek : nWeek )
4761             {
4762                 case 1: which = _T("first"); break;
4763                 case 2: which = _T("second"); break;
4764                 case 3: which = _T("third"); break;
4765                 case 4: which = _T("fourth"); break;
4766                 case 5: which = _T("fifth"); break;
4767
4768                 case -1: which = _T("last"); break;
4769             }
4770
4771             if ( nWeek < -1 )
4772             {
4773                 which += _T(" from end");
4774             }
4775
4776             s.Printf(_T("The %s %s of %s in %d"),
4777                      which.c_str(),
4778                      wxDateTime::GetWeekDayName(wday).c_str(),
4779                      wxDateTime::GetMonthName(month).c_str(),
4780                      year);
4781
4782             return s;
4783         }
4784     };
4785
4786     // the array data was generated by the following python program
4787     /*
4788 from DateTime import *
4789 from whrandom import *
4790 from string import *
4791
4792 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4793 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4794
4795 week = DateTimeDelta(7)
4796
4797 for n in range(20):
4798     year = randint(1900, 2100)
4799     month = randint(1, 12)
4800     day = randint(1, 28)
4801     dt = DateTime(year, month, day)
4802     wday = dt.day_of_week
4803
4804     countFromEnd = choice([-1, 1])
4805     weekNum = 0;
4806
4807     while dt.month is month:
4808         dt = dt - countFromEnd * week
4809         weekNum = weekNum + countFromEnd
4810
4811     data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
4812
4813     print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
4814           "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
4815     */
4816
4817     static const WeekDateTestData weekDatesTestData[] =
4818     {
4819         { { 20, wxDateTime::Mar, 2045 },  3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
4820         { {  5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
4821         { { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
4822         { { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
4823         { {  4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
4824         { {  2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
4825         { { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
4826         { {  5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
4827         { { 11, wxDateTime::Aug, 1900 },  2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
4828         { { 14, wxDateTime::Feb, 1945 },  2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
4829         { { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
4830         { {  9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
4831         { { 20, wxDateTime::Jun, 1927 },  3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
4832         { {  2, wxDateTime::Aug, 2000 },  1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
4833         { { 20, wxDateTime::Apr, 2044 },  3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
4834         { { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
4835         { { 25, wxDateTime::Jul, 2069 },  4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
4836         { {  3, wxDateTime::Apr, 1925 },  1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
4837         { { 21, wxDateTime::Mar, 2093 },  3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
4838         { {  3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
4839     };
4840
4841     static const wxChar *fmt = _T("%d-%b-%Y");
4842
4843     wxDateTime dt;
4844     for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
4845     {
4846         const WeekDateTestData& wd = weekDatesTestData[n];
4847
4848         dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
4849
4850         wxPrintf(_T("%s is %s"), wd.Format().c_str(), dt.Format(fmt).c_str());
4851
4852         const Date& d = wd.date;
4853         if ( d.SameDay(dt.GetTm()) )
4854         {
4855             wxPuts(_T(" (ok)"));
4856         }
4857         else
4858         {
4859             dt.Set(d.day, d.month, d.year);
4860
4861             wxPrintf(_T(" (ERROR: should be %s)\n"), dt.Format(fmt).c_str());
4862         }
4863     }
4864 }
4865
4866 // test the computation of (ISO) week numbers
4867 static void TestTimeWNumber()
4868 {
4869     wxPuts(_T("\n*** wxDateTime week number test ***"));
4870
4871     struct WeekNumberTestData
4872     {
4873         Date date;                          // the date
4874         wxDateTime::wxDateTime_t week;      // the week number in the year
4875         wxDateTime::wxDateTime_t wmon;      // the week number in the month
4876         wxDateTime::wxDateTime_t wmon2;     // same but week starts with Sun
4877         wxDateTime::wxDateTime_t dnum;      // day number in the year
4878     };
4879
4880     // data generated with the following python script:
4881     /*
4882 from DateTime import *
4883 from whrandom import *
4884 from string import *
4885
4886 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4887 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4888
4889 def GetMonthWeek(dt):
4890     weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
4891     if weekNumMonth < 0:
4892         weekNumMonth = weekNumMonth + 53
4893     return weekNumMonth
4894
4895 def GetLastSundayBefore(dt):
4896     if dt.iso_week[2] == 7:
4897         return dt
4898     else:
4899         return dt - DateTimeDelta(dt.iso_week[2])
4900
4901 for n in range(20):
4902     year = randint(1900, 2100)
4903     month = randint(1, 12)
4904     day = randint(1, 28)
4905     dt = DateTime(year, month, day)
4906     dayNum = dt.day_of_year
4907     weekNum = dt.iso_week[1]
4908     weekNumMonth = GetMonthWeek(dt)
4909
4910     weekNumMonth2 = 0
4911     dtSunday = GetLastSundayBefore(dt)
4912
4913     while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
4914         weekNumMonth2 = weekNumMonth2 + 1
4915         dtSunday = dtSunday - DateTimeDelta(7)
4916
4917     data = { 'day': rjust(`day`, 2), \
4918              'month': monthNames[month - 1], \
4919              'year': year, \
4920              'weekNum': rjust(`weekNum`, 2), \
4921              'weekNumMonth': weekNumMonth, \
4922              'weekNumMonth2': weekNumMonth2, \
4923              'dayNum': rjust(`dayNum`, 3) }
4924
4925     print "        { { %(day)s, "\
4926           "wxDateTime::%(month)s, "\
4927           "%(year)d }, "\
4928           "%(weekNum)s, "\
4929           "%(weekNumMonth)s, "\
4930           "%(weekNumMonth2)s, "\
4931           "%(dayNum)s }," % data
4932
4933     */
4934     static const WeekNumberTestData weekNumberTestDates[] =
4935     {
4936         { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
4937         { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
4938         { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
4939         { {  1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
4940         { {  8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
4941         { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4,  81 },
4942         { {  7, wxDateTime::Jan, 1965 },  1, 2, 2,   7 },
4943         { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
4944         { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
4945         { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
4946         { {  2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
4947         { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
4948         { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
4949         { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
4950         { {  3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
4951         { { 23, wxDateTime::Feb, 1940 },  8, 4, 4,  54 },
4952         { {  2, wxDateTime::Jan, 1987 },  1, 1, 1,   2 },
4953         { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
4954         { {  2, wxDateTime::Feb, 2063 },  5, 1, 1,  33 },
4955         { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
4956     };
4957
4958     for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
4959     {
4960         const WeekNumberTestData& wn = weekNumberTestDates[n];
4961         const Date& d = wn.date;
4962
4963         wxDateTime dt = d.DT();
4964
4965         wxDateTime::wxDateTime_t
4966             week = dt.GetWeekOfYear(wxDateTime::Monday_First),
4967             wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
4968             wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4969             dnum = dt.GetDayOfYear();
4970
4971         wxPrintf(_T("%s: the day number is %d"), d.FormatDate().c_str(), dnum);
4972         if ( dnum == wn.dnum )
4973         {
4974             wxPrintf(_T(" (ok)"));
4975         }
4976         else
4977         {
4978             wxPrintf(_T(" (ERROR: should be %d)"), wn.dnum);
4979         }
4980
4981         wxPrintf(_T(", week in month = %d"), wmon);
4982         if ( wmon != wn.wmon )
4983         {
4984             wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon);
4985         }
4986
4987         wxPrintf(_T(" or %d"), wmon2);
4988         if ( wmon2 == wn.wmon2 )
4989         {
4990             wxPrintf(_T(" (ok)"));
4991         }
4992         else
4993         {
4994             wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon2);
4995         }
4996
4997         wxPrintf(_T(", week in year = %d"), week);
4998         if ( week != wn.week )
4999         {
5000             wxPrintf(_T(" (ERROR: should be %d)"), wn.week);
5001         }
5002
5003         wxPutchar(_T('\n'));
5004
5005         wxDateTime dt2(1, wxDateTime::Jan, d.year);
5006         dt2.SetToTheWeek(wn.week, dt.GetWeekDay());
5007         if ( dt2 != dt )
5008         {
5009             Date d2;
5010             d2.Init(dt2.GetTm());
5011             wxPrintf(_T("ERROR: SetToTheWeek() returned %s\n"),
5012                      d2.FormatDate().c_str());
5013         }
5014     }
5015 }
5016
5017 // test DST calculations
5018 static void TestTimeDST()
5019 {
5020     wxPuts(_T("\n*** wxDateTime DST test ***"));
5021
5022     wxPrintf(_T("DST is%s in effect now.\n\n"),
5023              wxDateTime::Now().IsDST() ? _T("") : _T(" not"));
5024
5025     // taken from http://www.energy.ca.gov/daylightsaving.html
5026     static const Date datesDST[2][2004 - 1900 + 1] =
5027     {
5028         {
5029             { 1, wxDateTime::Apr, 1990 },
5030             { 7, wxDateTime::Apr, 1991 },
5031             { 5, wxDateTime::Apr, 1992 },
5032             { 4, wxDateTime::Apr, 1993 },
5033             { 3, wxDateTime::Apr, 1994 },
5034             { 2, wxDateTime::Apr, 1995 },
5035             { 7, wxDateTime::Apr, 1996 },
5036             { 6, wxDateTime::Apr, 1997 },
5037             { 5, wxDateTime::Apr, 1998 },
5038             { 4, wxDateTime::Apr, 1999 },
5039             { 2, wxDateTime::Apr, 2000 },
5040             { 1, wxDateTime::Apr, 2001 },
5041             { 7, wxDateTime::Apr, 2002 },
5042             { 6, wxDateTime::Apr, 2003 },
5043             { 4, wxDateTime::Apr, 2004 },
5044         },
5045         {
5046             { 28, wxDateTime::Oct, 1990 },
5047             { 27, wxDateTime::Oct, 1991 },
5048             { 25, wxDateTime::Oct, 1992 },
5049             { 31, wxDateTime::Oct, 1993 },
5050             { 30, wxDateTime::Oct, 1994 },
5051             { 29, wxDateTime::Oct, 1995 },
5052             { 27, wxDateTime::Oct, 1996 },
5053             { 26, wxDateTime::Oct, 1997 },
5054             { 25, wxDateTime::Oct, 1998 },
5055             { 31, wxDateTime::Oct, 1999 },
5056             { 29, wxDateTime::Oct, 2000 },
5057             { 28, wxDateTime::Oct, 2001 },
5058             { 27, wxDateTime::Oct, 2002 },
5059             { 26, wxDateTime::Oct, 2003 },
5060             { 31, wxDateTime::Oct, 2004 },
5061         }
5062     };
5063
5064     int year;
5065     for ( year = 1990; year < 2005; year++ )
5066     {
5067         wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
5068                    dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
5069
5070         wxPrintf(_T("DST period in the US for year %d: from %s to %s"),
5071                  year, dtBegin.Format().c_str(), dtEnd.Format().c_str());
5072
5073         size_t n = year - 1990;
5074         const Date& dBegin = datesDST[0][n];
5075         const Date& dEnd = datesDST[1][n];
5076
5077         if ( dBegin.SameDay(dtBegin.GetTm()) && dEnd.SameDay(dtEnd.GetTm()) )
5078         {
5079             wxPuts(_T(" (ok)"));
5080         }
5081         else
5082         {
5083             wxPrintf(_T(" (ERROR: should be %s %d to %s %d)\n"),
5084                      wxDateTime::GetMonthName(dBegin.month).c_str(), dBegin.day,
5085                      wxDateTime::GetMonthName(dEnd.month).c_str(), dEnd.day);
5086         }
5087     }
5088
5089     wxPuts(_T(""));
5090
5091     for ( year = 1990; year < 2005; year++ )
5092     {
5093         wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
5094                  year,
5095                  wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
5096                  wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
5097     }
5098 }
5099
5100 // test wxDateTime -> text conversion
5101 static void TestTimeFormat()
5102 {
5103     wxPuts(_T("\n*** wxDateTime formatting test ***"));
5104
5105     // some information may be lost during conversion, so store what kind
5106     // of info should we recover after a round trip
5107     enum CompareKind
5108     {
5109         CompareNone,        // don't try comparing
5110         CompareBoth,        // dates and times should be identical
5111         CompareDate,        // dates only
5112         CompareTime         // time only
5113     };
5114
5115     static const struct
5116     {
5117         CompareKind compareKind;
5118         const wxChar *format;
5119     } formatTestFormats[] =
5120     {
5121        { CompareBoth, _T("---> %c") },
5122        { CompareDate, _T("Date is %A, %d of %B, in year %Y") },
5123        { CompareBoth, _T("Date is %x, time is %X") },
5124        { CompareTime, _T("Time is %H:%M:%S or %I:%M:%S %p") },
5125        { CompareNone, _T("The day of year: %j, the week of year: %W") },
5126        { CompareDate, _T("ISO date without separators: %Y%m%d") },
5127     };
5128
5129     static const Date formatTestDates[] =
5130     {
5131         { 29, wxDateTime::May, 1976, 18, 30, 00 },
5132         { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
5133 #if 0
5134         // this test can't work for other centuries because it uses two digit
5135         // years in formats, so don't even try it
5136         { 29, wxDateTime::May, 2076, 18, 30, 00 },
5137         { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
5138         { 01, wxDateTime::Jan,  -52, 03, 16, 47 },
5139 #endif
5140     };
5141
5142     // an extra test (as it doesn't depend on date, don't do it in the loop)
5143     wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
5144
5145     for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
5146     {
5147         wxPuts(_T(""));
5148
5149         wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
5150         for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
5151         {
5152             wxString s = dt.Format(formatTestFormats[n].format);
5153             wxPrintf(_T("%s"), s.c_str());
5154
5155             // what can we recover?
5156             int kind = formatTestFormats[n].compareKind;
5157
5158             // convert back
5159             wxDateTime dt2;
5160             const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
5161             if ( !result )
5162             {
5163                 // converion failed - should it have?
5164                 if ( kind == CompareNone )
5165                     wxPuts(_T(" (ok)"));
5166                 else
5167                     wxPuts(_T(" (ERROR: conversion back failed)"));
5168             }
5169             else if ( *result )
5170             {
5171                 // should have parsed the entire string
5172                 wxPuts(_T(" (ERROR: conversion back stopped too soon)"));
5173             }
5174             else
5175             {
5176                 bool equal = false; // suppress compilaer warning
5177                 switch ( kind )
5178                 {
5179                     case CompareBoth:
5180                         equal = dt2 == dt;
5181                         break;
5182
5183                     case CompareDate:
5184                         equal = dt.IsSameDate(dt2);
5185                         break;
5186
5187                     case CompareTime:
5188                         equal = dt.IsSameTime(dt2);
5189                         break;
5190                 }
5191
5192                 if ( !equal )
5193                 {
5194                     wxPrintf(_T(" (ERROR: got back '%s' instead of '%s')\n"),
5195                            dt2.Format().c_str(), dt.Format().c_str());
5196                 }
5197                 else
5198                 {
5199                     wxPuts(_T(" (ok)"));
5200                 }
5201             }
5202         }
5203     }
5204 }
5205
5206 // test text -> wxDateTime conversion
5207 static void TestTimeParse()
5208 {
5209     wxPuts(_T("\n*** wxDateTime parse test ***"));
5210
5211     struct ParseTestData
5212     {
5213         const wxChar *format;
5214         Date date;
5215         bool good;
5216     };
5217
5218     static const ParseTestData parseTestDates[] =
5219     {
5220         { _T("Sat, 18 Dec 1999 00:46:40 +0100"), { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, true },
5221         { _T("Wed, 1 Dec 1999 05:17:20 +0300"),  {  1, wxDateTime::Dec, 1999, 03, 17, 20 }, true },
5222     };
5223
5224     for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
5225     {
5226         const wxChar *format = parseTestDates[n].format;
5227
5228         wxPrintf(_T("%s => "), format);
5229
5230         wxDateTime dt;
5231         if ( dt.ParseRfc822Date(format) )
5232         {
5233             wxPrintf(_T("%s "), dt.Format().c_str());
5234
5235             if ( parseTestDates[n].good )
5236             {
5237                 wxDateTime dtReal = parseTestDates[n].date.DT();
5238                 if ( dt == dtReal )
5239                 {
5240                     wxPuts(_T("(ok)"));
5241                 }
5242                 else
5243                 {
5244                     wxPrintf(_T("(ERROR: should be %s)\n"), dtReal.Format().c_str());
5245                 }
5246             }
5247             else
5248             {
5249                 wxPuts(_T("(ERROR: bad format)"));
5250             }
5251         }
5252         else
5253         {
5254             wxPrintf(_T("bad format (%s)\n"),
5255                    parseTestDates[n].good ? "ERROR" : "ok");
5256         }
5257     }
5258 }
5259
5260 static void TestDateTimeInteractive()
5261 {
5262     wxPuts(_T("\n*** interactive wxDateTime tests ***"));
5263
5264     wxChar buf[128];
5265
5266     for ( ;; )
5267     {
5268         wxPrintf(_T("Enter a date: "));
5269         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
5270             break;
5271
5272         // kill the last '\n'
5273         buf[wxStrlen(buf) - 1] = 0;
5274
5275         wxDateTime dt;
5276         const wxChar *p = dt.ParseDate(buf);
5277         if ( !p )
5278         {
5279             wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
5280
5281             continue;
5282         }
5283         else if ( *p )
5284         {
5285             wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
5286         }
5287
5288         wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
5289                  dt.Format(_T("%b %d, %Y")).c_str(),
5290                  dt.GetDayOfYear(),
5291                  dt.GetWeekOfMonth(wxDateTime::Monday_First),
5292                  dt.GetWeekOfMonth(wxDateTime::Sunday_First),
5293                  dt.GetWeekOfYear(wxDateTime::Monday_First));
5294     }
5295
5296     wxPuts(_T("\n*** done ***"));
5297 }
5298
5299 static void TestTimeMS()
5300 {
5301     wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
5302
5303     wxDateTime dt1 = wxDateTime::Now(),
5304                dt2 = wxDateTime::UNow();
5305
5306     wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
5307     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
5308     wxPrintf(_T("Dummy loop: "));
5309     for ( int i = 0; i < 6000; i++ )
5310     {
5311         //for ( int j = 0; j < 10; j++ )
5312         {
5313             wxString s;
5314             s.Printf(_T("%g"), sqrt(i));
5315         }
5316
5317         if ( !(i % 100) )
5318             putchar('.');
5319     }
5320     wxPuts(_T(", done"));
5321
5322     dt1 = dt2;
5323     dt2 = wxDateTime::UNow();
5324     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
5325
5326     wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
5327
5328     wxPuts(_T("\n*** done ***"));
5329 }
5330
5331 static void TestTimeArithmetics()
5332 {
5333     wxPuts(_T("\n*** testing arithmetic operations on wxDateTime ***"));
5334
5335     static const struct ArithmData
5336     {
5337         ArithmData(const wxDateSpan& sp, const wxChar *nam)
5338             : span(sp), name(nam) { }
5339
5340         wxDateSpan span;
5341         const wxChar *name;
5342     } testArithmData[] =
5343     {
5344         ArithmData(wxDateSpan::Day(), _T("day")),
5345         ArithmData(wxDateSpan::Week(), _T("week")),
5346         ArithmData(wxDateSpan::Month(), _T("month")),
5347         ArithmData(wxDateSpan::Year(), _T("year")),
5348         ArithmData(wxDateSpan(1, 2, 3, 4), _T("year, 2 months, 3 weeks, 4 days")),
5349     };
5350
5351     wxDateTime dt(29, wxDateTime::Dec, 1999), dt1, dt2;
5352
5353     for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
5354     {
5355         wxDateSpan span = testArithmData[n].span;
5356         dt1 = dt + span;
5357         dt2 = dt - span;
5358
5359         const wxChar *name = testArithmData[n].name;
5360         wxPrintf(_T("%s + %s = %s, %s - %s = %s\n"),
5361                dt.FormatISODate().c_str(), name, dt1.FormatISODate().c_str(),
5362                dt.FormatISODate().c_str(), name, dt2.FormatISODate().c_str());
5363
5364         wxPrintf(_T("Going back: %s"), (dt1 - span).FormatISODate().c_str());
5365         if ( dt1 - span == dt )
5366         {
5367             wxPuts(_T(" (ok)"));
5368         }
5369         else
5370         {
5371             wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
5372         }
5373
5374         wxPrintf(_T("Going forward: %s"), (dt2 + span).FormatISODate().c_str());
5375         if ( dt2 + span == dt )
5376         {
5377             wxPuts(_T(" (ok)"));
5378         }
5379         else
5380         {
5381             wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
5382         }
5383
5384         wxPrintf(_T("Double increment: %s"), (dt2 + 2*span).FormatISODate().c_str());
5385         if ( dt2 + 2*span == dt1 )
5386         {
5387             wxPuts(_T(" (ok)"));
5388         }
5389         else
5390         {
5391             wxPrintf(_T(" (ERROR: should be %s)\n"), dt2.FormatISODate().c_str());
5392         }
5393
5394         wxPuts(_T(""));
5395     }
5396 }
5397
5398 static void TestTimeHolidays()
5399 {
5400     wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
5401
5402     wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
5403     wxDateTime dtStart(1, tm.mon, tm.year),
5404                dtEnd = dtStart.GetLastMonthDay();
5405
5406     wxDateTimeArray hol;
5407     wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
5408
5409     const wxChar *format = _T("%d-%b-%Y (%a)");
5410
5411     wxPrintf(_T("All holidays between %s and %s:\n"),
5412            dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
5413
5414     size_t count = hol.GetCount();
5415     for ( size_t n = 0; n < count; n++ )
5416     {
5417         wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
5418     }
5419
5420     wxPuts(_T(""));
5421 }
5422
5423 static void TestTimeZoneBug()
5424 {
5425     wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
5426
5427     wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
5428     for ( int i = 0; i < 31; i++ )
5429     {
5430         wxPrintf(_T("Date %s: week day %s.\n"),
5431                date.Format(_T("%d-%m-%Y")).c_str(),
5432                date.GetWeekDayName(date.GetWeekDay()).c_str());
5433
5434         date += wxDateSpan::Day();
5435     }
5436
5437     wxPuts(_T(""));
5438 }
5439
5440 static void TestTimeSpanFormat()
5441 {
5442     wxPuts(_T("\n*** wxTimeSpan tests ***"));
5443
5444     static const wxChar *formats[] =
5445     {
5446         _T("(default) %H:%M:%S"),
5447         _T("%E weeks and %D days"),
5448         _T("%l milliseconds"),
5449         _T("(with ms) %H:%M:%S:%l"),
5450         _T("100%% of minutes is %M"),       // test "%%"
5451         _T("%D days and %H hours"),
5452         _T("or also %S seconds"),
5453     };
5454
5455     wxTimeSpan ts1(1, 2, 3, 4),
5456                 ts2(111, 222, 333);
5457     for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
5458     {
5459         wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
5460                ts1.Format(formats[n]).c_str(),
5461                ts2.Format(formats[n]).c_str());
5462     }
5463
5464     wxPuts(_T(""));
5465 }
5466
5467 #endif // TEST_DATETIME
5468
5469 // ----------------------------------------------------------------------------
5470 // wxTextInput/OutputStream
5471 // ----------------------------------------------------------------------------
5472
5473 #ifdef TEST_TEXTSTREAM
5474
5475 #include "wx/txtstrm.h"
5476 #include "wx/wfstream.h"
5477
5478 static void TestTextInputStream()
5479 {
5480     wxPuts(_T("\n*** wxTextInputStream test ***"));
5481
5482     wxFileInputStream fsIn(_T("testdata.fc"));
5483     if ( !fsIn.Ok() )
5484     {
5485         wxPuts(_T("ERROR: couldn't open file."));
5486     }
5487     else
5488     {
5489         wxTextInputStream tis(fsIn);
5490
5491         size_t line = 1;
5492         for ( ;; )
5493         {
5494             const wxString s = tis.ReadLine();
5495
5496             // line could be non empty if the last line of the file isn't
5497             // terminated with EOL
5498             if ( fsIn.Eof() && s.empty() )
5499                 break;
5500
5501             wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
5502         }
5503     }
5504 }
5505
5506 #endif // TEST_TEXTSTREAM
5507
5508 // ----------------------------------------------------------------------------
5509 // threads
5510 // ----------------------------------------------------------------------------
5511
5512 #ifdef TEST_THREADS
5513
5514 #include "wx/thread.h"
5515
5516 static size_t gs_counter = (size_t)-1;
5517 static wxCriticalSection gs_critsect;
5518 static wxSemaphore gs_cond;
5519
5520 class MyJoinableThread : public wxThread
5521 {
5522 public:
5523     MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
5524         { m_n = n; Create(); }
5525
5526     // thread execution starts here
5527     virtual ExitCode Entry();
5528
5529 private:
5530     size_t m_n;
5531 };
5532
5533 wxThread::ExitCode MyJoinableThread::Entry()
5534 {
5535     unsigned long res = 1;
5536     for ( size_t n = 1; n < m_n; n++ )
5537     {
5538         res *= n;
5539
5540         // it's a loooong calculation :-)
5541         Sleep(100);
5542     }
5543
5544     return (ExitCode)res;
5545 }
5546
5547 class MyDetachedThread : public wxThread
5548 {
5549 public:
5550     MyDetachedThread(size_t n, wxChar ch)
5551     {
5552         m_n = n;
5553         m_ch = ch;
5554         m_cancelled = false;
5555
5556         Create();
5557     }
5558
5559     // thread execution starts here
5560     virtual ExitCode Entry();
5561
5562     // and stops here
5563     virtual void OnExit();
5564
5565 private:
5566     size_t m_n; // number of characters to write
5567     wxChar m_ch;  // character to write
5568
5569     bool m_cancelled;   // false if we exit normally
5570 };
5571
5572 wxThread::ExitCode MyDetachedThread::Entry()
5573 {
5574     {
5575         wxCriticalSectionLocker lock(gs_critsect);
5576         if ( gs_counter == (size_t)-1 )
5577             gs_counter = 1;
5578         else
5579             gs_counter++;
5580     }
5581
5582     for ( size_t n = 0; n < m_n; n++ )
5583     {
5584         if ( TestDestroy() )
5585         {
5586             m_cancelled = true;
5587
5588             break;
5589         }
5590
5591         putchar(m_ch);
5592         fflush(stdout);
5593
5594         wxThread::Sleep(100);
5595     }
5596
5597     return 0;
5598 }
5599
5600 void MyDetachedThread::OnExit()
5601 {
5602     wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
5603
5604     wxCriticalSectionLocker lock(gs_critsect);
5605     if ( !--gs_counter && !m_cancelled )
5606         gs_cond.Post();
5607 }
5608
5609 static void TestDetachedThreads()
5610 {
5611     wxPuts(_T("\n*** Testing detached threads ***"));
5612
5613     static const size_t nThreads = 3;
5614     MyDetachedThread *threads[nThreads];
5615     size_t n;
5616     for ( n = 0; n < nThreads; n++ )
5617     {
5618         threads[n] = new MyDetachedThread(10, 'A' + n);
5619     }
5620
5621     threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
5622     threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
5623
5624     for ( n = 0; n < nThreads; n++ )
5625     {
5626         threads[n]->Run();
5627     }
5628
5629     // wait until all threads terminate
5630     gs_cond.Wait();
5631
5632     wxPuts(_T(""));
5633 }
5634
5635 static void TestJoinableThreads()
5636 {
5637     wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
5638
5639     // calc 10! in the background
5640     MyJoinableThread thread(10);
5641     thread.Run();
5642
5643     wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
5644            (unsigned long)thread.Wait());
5645 }
5646
5647 static void TestThreadSuspend()
5648 {
5649     wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
5650
5651     MyDetachedThread *thread = new MyDetachedThread(15, 'X');
5652
5653     thread->Run();
5654
5655     // this is for this demo only, in a real life program we'd use another
5656     // condition variable which would be signaled from wxThread::Entry() to
5657     // tell us that the thread really started running - but here just wait a
5658     // bit and hope that it will be enough (the problem is, of course, that
5659     // the thread might still not run when we call Pause() which will result
5660     // in an error)
5661     wxThread::Sleep(300);
5662
5663     for ( size_t n = 0; n < 3; n++ )
5664     {
5665         thread->Pause();
5666
5667         wxPuts(_T("\nThread suspended"));
5668         if ( n > 0 )
5669         {
5670             // don't sleep but resume immediately the first time
5671             wxThread::Sleep(300);
5672         }
5673         wxPuts(_T("Going to resume the thread"));
5674
5675         thread->Resume();
5676     }
5677
5678     wxPuts(_T("Waiting until it terminates now"));
5679
5680     // wait until the thread terminates
5681     gs_cond.Wait();
5682
5683     wxPuts(_T(""));
5684 }
5685
5686 static void TestThreadDelete()
5687 {
5688     // As above, using Sleep() is only for testing here - we must use some
5689     // synchronisation object instead to ensure that the thread is still
5690     // running when we delete it - deleting a detached thread which already
5691     // terminated will lead to a crash!
5692
5693     wxPuts(_T("\n*** Testing thread delete function ***"));
5694
5695     MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
5696
5697     thread0->Delete();
5698
5699     wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
5700
5701     MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
5702
5703     thread1->Run();
5704
5705     wxThread::Sleep(300);
5706
5707     thread1->Delete();
5708
5709     wxPuts(_T("\nDeleted a running thread."));
5710
5711     MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
5712
5713     thread2->Run();
5714
5715     wxThread::Sleep(300);
5716
5717     thread2->Pause();
5718
5719     thread2->Delete();
5720
5721     wxPuts(_T("\nDeleted a sleeping thread."));
5722
5723     MyJoinableThread thread3(20);
5724     thread3.Run();
5725
5726     thread3.Delete();
5727
5728     wxPuts(_T("\nDeleted a joinable thread."));
5729
5730     MyJoinableThread thread4(2);
5731     thread4.Run();
5732
5733     wxThread::Sleep(300);
5734
5735     thread4.Delete();
5736
5737     wxPuts(_T("\nDeleted a joinable thread which already terminated."));
5738
5739     wxPuts(_T(""));
5740 }
5741
5742 class MyWaitingThread : public wxThread
5743 {
5744 public:
5745     MyWaitingThread( wxMutex *mutex, wxCondition *condition )
5746     {
5747         m_mutex = mutex;
5748         m_condition = condition;
5749
5750         Create();
5751     }
5752
5753     virtual ExitCode Entry()
5754     {
5755         wxPrintf(_T("Thread %lu has started running.\n"), GetId());
5756         fflush(stdout);
5757
5758         gs_cond.Post();
5759
5760         wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
5761         fflush(stdout);
5762
5763         m_mutex->Lock();
5764         m_condition->Wait();
5765         m_mutex->Unlock();
5766
5767         wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
5768         fflush(stdout);
5769
5770         return 0;
5771     }
5772
5773 private:
5774     wxMutex *m_mutex;
5775     wxCondition *m_condition;
5776 };
5777
5778 static void TestThreadConditions()
5779 {
5780     wxMutex mutex;
5781     wxCondition condition(mutex);
5782
5783     // otherwise its difficult to understand which log messages pertain to
5784     // which condition
5785     //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
5786     //           condition.GetId(), gs_cond.GetId());
5787
5788     // create and launch threads
5789     MyWaitingThread *threads[10];
5790
5791     size_t n;
5792     for ( n = 0; n < WXSIZEOF(threads); n++ )
5793     {
5794         threads[n] = new MyWaitingThread( &mutex, &condition );
5795     }
5796
5797     for ( n = 0; n < WXSIZEOF(threads); n++ )
5798     {
5799         threads[n]->Run();
5800     }
5801
5802     // wait until all threads run
5803     wxPuts(_T("Main thread is waiting for the other threads to start"));
5804     fflush(stdout);
5805
5806     size_t nRunning = 0;
5807     while ( nRunning < WXSIZEOF(threads) )
5808     {
5809         gs_cond.Wait();
5810
5811         nRunning++;
5812
5813         wxPrintf(_T("Main thread: %u already running\n"), nRunning);
5814         fflush(stdout);
5815     }
5816
5817     wxPuts(_T("Main thread: all threads started up."));
5818     fflush(stdout);
5819
5820     wxThread::Sleep(500);
5821
5822 #if 1
5823     // now wake one of them up
5824     wxPrintf(_T("Main thread: about to signal the condition.\n"));
5825     fflush(stdout);
5826     condition.Signal();
5827 #endif
5828
5829     wxThread::Sleep(200);
5830
5831     // wake all the (remaining) threads up, so that they can exit
5832     wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
5833     fflush(stdout);
5834     condition.Broadcast();
5835
5836     // give them time to terminate (dirty!)
5837     wxThread::Sleep(500);
5838 }
5839
5840 #include "wx/utils.h"
5841
5842 class MyExecThread : public wxThread
5843 {
5844 public:
5845     MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
5846                                             m_command(command)
5847     {
5848         Create();
5849     }
5850
5851     virtual ExitCode Entry()
5852     {
5853         return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
5854     }
5855
5856 private:
5857     wxString m_command;
5858 };
5859
5860 static void TestThreadExec()
5861 {
5862     wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
5863
5864     MyExecThread thread(_T("true"));
5865     thread.Run();
5866
5867     wxPrintf(_T("Main program exit code: %ld.\n"),
5868              wxExecute(_T("false"), wxEXEC_SYNC));
5869
5870     wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
5871 }
5872
5873 // semaphore tests
5874 #include "wx/datetime.h"
5875
5876 class MySemaphoreThread : public wxThread
5877 {
5878 public:
5879     MySemaphoreThread(int i, wxSemaphore *sem)
5880         : wxThread(wxTHREAD_JOINABLE),
5881           m_sem(sem),
5882           m_i(i)
5883     {
5884         Create();
5885     }
5886
5887     virtual ExitCode Entry()
5888     {
5889         wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
5890                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5891
5892         m_sem->Wait();
5893
5894         wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
5895                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5896
5897         Sleep(1000);
5898
5899         wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
5900                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5901
5902         m_sem->Post();
5903
5904         return 0;
5905     }
5906
5907 private:
5908     wxSemaphore *m_sem;
5909     int m_i;
5910 };
5911
5912 WX_DEFINE_ARRAY(wxThread *, ArrayThreads);
5913
5914 static void TestSemaphore()
5915 {
5916     wxPuts(_T("*** Testing wxSemaphore class. ***"));
5917
5918     static const int SEM_LIMIT = 3;
5919
5920     wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
5921     ArrayThreads threads;
5922
5923     for ( int i = 0; i < 3*SEM_LIMIT; i++ )
5924     {
5925         threads.Add(new MySemaphoreThread(i, &sem));
5926         threads.Last()->Run();
5927     }
5928
5929     for ( size_t n = 0; n < threads.GetCount(); n++ )
5930     {
5931         threads[n]->Wait();
5932         delete threads[n];
5933     }
5934 }
5935
5936 #endif // TEST_THREADS
5937
5938 // ----------------------------------------------------------------------------
5939 // arrays
5940 // ----------------------------------------------------------------------------
5941
5942 #ifdef TEST_ARRAYS
5943
5944 #include "wx/dynarray.h"
5945
5946 typedef unsigned short ushort;
5947
5948 #define DefineCompare(name, T)                                                \
5949                                                                               \
5950 int wxCMPFUNC_CONV name ## CompareValues(T first, T second)                   \
5951 {                                                                             \
5952     return first - second;                                                    \
5953 }                                                                             \
5954                                                                               \
5955 int wxCMPFUNC_CONV name ## Compare(T* first, T* second)                       \
5956 {                                                                             \
5957     return *first - *second;                                                  \
5958 }                                                                             \
5959                                                                               \
5960 int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second)                    \
5961 {                                                                             \
5962     return *second - *first;                                                  \
5963 }                                                                             \
5964
5965 DefineCompare(UShort, ushort);
5966 DefineCompare(Int, int);
5967
5968 // test compilation of all macros
5969 WX_DEFINE_ARRAY_SHORT(ushort, wxArrayUShort);
5970 WX_DEFINE_SORTED_ARRAY_SHORT(ushort, wxSortedArrayUShortNoCmp);
5971 WX_DEFINE_SORTED_ARRAY_CMP_SHORT(ushort, UShortCompareValues, wxSortedArrayUShort);
5972 WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt);
5973
5974 WX_DECLARE_OBJARRAY(Bar, ArrayBars);
5975 #include "wx/arrimpl.cpp"
5976 WX_DEFINE_OBJARRAY(ArrayBars);
5977
5978 static void PrintArray(const wxChar* name, const wxArrayString& array)
5979 {
5980     wxPrintf(_T("Dump of the array '%s'\n"), name);
5981
5982     size_t nCount = array.GetCount();
5983     for ( size_t n = 0; n < nCount; n++ )
5984     {
5985         wxPrintf(_T("\t%s[%u] = '%s'\n"), name, n, array[n].c_str());
5986     }
5987 }
5988
5989 static void PrintArray(const wxChar* name, const wxSortedArrayString& array)
5990 {
5991     wxPrintf(_T("Dump of the array '%s'\n"), name);
5992
5993     size_t nCount = array.GetCount();
5994     for ( size_t n = 0; n < nCount; n++ )
5995     {
5996         wxPrintf(_T("\t%s[%u] = '%s'\n"), name, n, array[n].c_str());
5997     }
5998 }
5999
6000 int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
6001                                     const wxString& second)
6002 {
6003     return first.length() - second.length();
6004 }
6005
6006 #define TestArrayOf(name)                                                     \
6007                                                                               \
6008 static void PrintArray(const wxChar* name, const wxSortedArray##name & array) \
6009 {                                                                             \
6010     wxPrintf(_T("Dump of the array '%s'\n"), name);                           \
6011                                                                               \
6012     size_t nCount = array.GetCount();                                         \
6013     for ( size_t n = 0; n < nCount; n++ )                                     \
6014     {                                                                         \
6015         wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]);                   \
6016     }                                                                         \
6017 }                                                                             \
6018                                                                               \
6019 static void PrintArray(const wxChar* name, const wxArray##name & array)       \
6020 {                                                                             \
6021     wxPrintf(_T("Dump of the array '%s'\n"), name);                           \
6022                                                                               \
6023     size_t nCount = array.GetCount();                                         \
6024     for ( size_t n = 0; n < nCount; n++ )                                     \
6025     {                                                                         \
6026         wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]);                   \
6027     }                                                                         \
6028 }                                                                             \
6029                                                                               \
6030 static void TestArrayOf ## name ## s()                                        \
6031 {                                                                             \
6032     wxPrintf(_T("*** Testing wxArray%s ***\n"), #name);                       \
6033                                                                               \
6034     wxArray##name a;                                                          \
6035     a.Add(1);                                                                 \
6036     a.Add(17,2);                                                              \
6037     a.Add(5,3);                                                               \
6038     a.Add(3,4);                                                               \
6039                                                                               \
6040     wxPuts(_T("Initially:"));                                                 \
6041     PrintArray(_T("a"), a);                                                   \
6042                                                                               \
6043     wxPuts(_T("After sort:"));                                                \
6044     a.Sort(name ## Compare);                                                  \
6045     PrintArray(_T("a"), a);                                                   \
6046                                                                               \
6047     wxPuts(_T("After reverse sort:"));                                        \
6048     a.Sort(name ## RevCompare);                                               \
6049     PrintArray(_T("a"), a);                                                   \
6050                                                                               \
6051     wxSortedArray##name b;                                                    \
6052     b.Add(1);                                                                 \
6053     b.Add(17);                                                                \
6054     b.Add(5);                                                                 \
6055     b.Add(3);                                                                 \
6056                                                                               \
6057     wxPuts(_T("Sorted array initially:"));                                    \
6058     PrintArray(_T("b"), b);                                                       \
6059 }
6060
6061 TestArrayOf(UShort);
6062 TestArrayOf(Int);
6063
6064 static void TestStlArray()
6065 {
6066     wxPuts(_T("*** Testing std::vector operations ***\n"));
6067
6068     {
6069         wxArrayInt list1;
6070         wxArrayInt::iterator it, en;
6071         wxArrayInt::reverse_iterator rit, ren;
6072         int i;
6073         for ( i = 0; i < 5; ++i )
6074             list1.push_back(i);
6075
6076         for ( it = list1.begin(), en = list1.end(), i = 0;
6077               it != en; ++it, ++i )
6078             if ( *it != i )
6079                 wxPuts(_T("Error in iterator\n"));
6080
6081         for ( rit = list1.rbegin(), ren = list1.rend(), i = 4;
6082               rit != ren; ++rit, --i )
6083             if ( *rit != i )
6084                 wxPuts(_T("Error in reverse_iterator\n"));
6085
6086         if ( *list1.rbegin() != *(list1.end()-1) ||
6087              *list1.begin() != *(list1.rend()-1) )
6088             wxPuts(_T("Error in iterator/reverse_iterator\n"));
6089
6090         it = list1.begin()+1;
6091         rit = list1.rbegin()+1;
6092         if ( *list1.begin() != *(it-1) ||
6093              *list1.rbegin() != *(rit-1) )
6094             wxPuts(_T("Error in iterator/reverse_iterator\n"));
6095
6096         if ( list1.front() != 0 || list1.back() != 4 )
6097             wxPuts(_T("Error in front()/back()\n"));
6098
6099         list1.erase(list1.begin());
6100         list1.erase(list1.end()-1);
6101
6102         for ( it = list1.begin(), en = list1.end(), i = 1;
6103               it != en; ++it, ++i )
6104             if ( *it != i )
6105                 wxPuts(_T("Error in erase()\n"));
6106     }
6107
6108     wxPuts(_T("*** Testing std::vector operations finished ***\n"));
6109 }
6110
6111 static void TestArrayOfObjects()
6112 {
6113     wxPuts(_T("*** Testing wxObjArray ***\n"));
6114
6115     {
6116         ArrayBars bars;
6117         Bar bar(_T("second bar (two copies!)"));
6118
6119         wxPrintf(_T("Initially: %u objects in the array, %u objects total.\n"),
6120                bars.GetCount(), Bar::GetNumber());
6121
6122         bars.Add(new Bar(_T("first bar")));
6123         bars.Add(bar,2);
6124
6125         wxPrintf(_T("Now: %u objects in the array, %u objects total.\n"),
6126                bars.GetCount(), Bar::GetNumber());
6127
6128         bars.RemoveAt(1, bars.GetCount() - 1);
6129
6130         wxPrintf(_T("After removing all but first element: %u objects in the ")
6131                  _T("array, %u objects total.\n"),
6132                bars.GetCount(), Bar::GetNumber());
6133
6134         bars.Empty();
6135
6136         wxPrintf(_T("After Empty(): %u objects in the array, %u objects total.\n"),
6137                bars.GetCount(), Bar::GetNumber());
6138     }
6139
6140     wxPrintf(_T("Finally: no more objects in the array, %u objects total.\n"),
6141            Bar::GetNumber());
6142 }
6143
6144 #endif // TEST_ARRAYS
6145
6146 // ----------------------------------------------------------------------------
6147 // strings
6148 // ----------------------------------------------------------------------------
6149
6150 #ifdef TEST_STRINGS
6151
6152 #include "wx/timer.h"
6153 #include "wx/tokenzr.h"
6154
6155 static void TestStringConstruction()
6156 {
6157     wxPuts(_T("*** Testing wxString constructores ***"));
6158
6159     #define TEST_CTOR(args, res)                                               \
6160         {                                                                      \
6161             wxString s args ;                                                  \
6162             wxPrintf(_T("wxString%s = %s "), #args, s.c_str());                      \
6163             if ( s == res )                                                    \
6164             {                                                                  \
6165                 wxPuts(_T("(ok)"));                                                  \
6166             }                                                                  \
6167             else                                                               \
6168             {                                                                  \
6169                 wxPrintf(_T("(ERROR: should be %s)\n"), res);                        \
6170             }                                                                  \
6171         }
6172
6173     TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
6174     TEST_CTOR((_T("Hello"), 4), _T("Hell"));
6175     TEST_CTOR((_T("Hello"), 5), _T("Hello"));
6176     // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
6177
6178     static const wxChar *s = _T("?really!");
6179     const wxChar *start = wxStrchr(s, _T('r'));
6180     const wxChar *end = wxStrchr(s, _T('!'));
6181     TEST_CTOR((start, end), _T("really"));
6182
6183     wxPuts(_T(""));
6184 }
6185
6186 static void TestString()
6187 {
6188     wxStopWatch sw;
6189
6190     wxString a, b, c;
6191
6192     a.reserve (128);
6193     b.reserve (128);
6194     c.reserve (128);
6195
6196     for (int i = 0; i < 1000000; ++i)
6197     {
6198         a = _T("Hello");
6199         b = _T(" world");
6200         c = _T("! How'ya doin'?");
6201         a += b;
6202         a += c;
6203         c = _T("Hello world! What's up?");
6204         if (c != a)
6205             c = _T("Doh!");
6206     }
6207
6208     wxPrintf(_T("TestString elapsed time: %ld\n"), sw.Time());
6209 }
6210
6211 static void TestPChar()
6212 {
6213     wxStopWatch sw;
6214
6215     wxChar a [128];
6216     wxChar b [128];
6217     wxChar c [128];
6218
6219     for (int i = 0; i < 1000000; ++i)
6220     {
6221         wxStrcpy (a, _T("Hello"));
6222         wxStrcpy (b, _T(" world"));
6223         wxStrcpy (c, _T("! How'ya doin'?"));
6224         wxStrcat (a, b);
6225         wxStrcat (a, c);
6226         wxStrcpy (c, _T("Hello world! What's up?"));
6227         if (wxStrcmp (c, a) == 0)
6228             wxStrcpy (c, _T("Doh!"));
6229     }
6230
6231     wxPrintf(_T("TestPChar elapsed time: %ld\n"), sw.Time());
6232 }
6233
6234 static void TestStringSub()
6235 {
6236     wxString s(_T("Hello, world!"));
6237
6238     wxPuts(_T("*** Testing wxString substring extraction ***"));
6239
6240     wxPrintf(_T("String = '%s'\n"), s.c_str());
6241     wxPrintf(_T("Left(5) = '%s'\n"), s.Left(5).c_str());
6242     wxPrintf(_T("Right(6) = '%s'\n"), s.Right(6).c_str());
6243     wxPrintf(_T("Mid(3, 5) = '%s'\n"), s(3, 5).c_str());
6244     wxPrintf(_T("Mid(3) = '%s'\n"), s.Mid(3).c_str());
6245     wxPrintf(_T("substr(3, 5) = '%s'\n"), s.substr(3, 5).c_str());
6246     wxPrintf(_T("substr(3) = '%s'\n"), s.substr(3).c_str());
6247
6248     static const wxChar *prefixes[] =
6249     {
6250         _T("Hello"),
6251         _T("Hello, "),
6252         _T("Hello, world!"),
6253         _T("Hello, world!!!"),
6254         _T(""),
6255         _T("Goodbye"),
6256         _T("Hi"),
6257     };
6258
6259     for ( size_t n = 0; n < WXSIZEOF(prefixes); n++ )
6260     {
6261         wxString prefix = prefixes[n], rest;
6262         bool rc = s.StartsWith(prefix, &rest);
6263         wxPrintf(_T("StartsWith('%s') = %s"), prefix.c_str(), rc ? _T("true") : _T("false"));
6264         if ( rc )
6265         {
6266             wxPrintf(_T(" (the rest is '%s')\n"), rest.c_str());
6267         }
6268         else
6269         {
6270             putchar('\n');
6271         }
6272     }
6273
6274     wxPuts(_T(""));
6275 }
6276
6277 static void TestStringFormat()
6278 {
6279     wxPuts(_T("*** Testing wxString formatting ***"));
6280
6281     wxString s;
6282     s.Printf(_T("%03d"), 18);
6283
6284     wxPrintf(_T("Number 18: %s\n"), wxString::Format(_T("%03d"), 18).c_str());
6285     wxPrintf(_T("Number 18: %s\n"), s.c_str());
6286
6287     wxPuts(_T(""));
6288 }
6289
6290 // returns "not found" for npos, value for all others
6291 static wxString PosToString(size_t res)
6292 {
6293     wxString s = res == wxString::npos ? wxString(_T("not found"))
6294                                        : wxString::Format(_T("%u"), res);
6295     return s;
6296 }
6297
6298 static void TestStringFind()
6299 {
6300     wxPuts(_T("*** Testing wxString find() functions ***"));
6301
6302     static const wxChar *strToFind = _T("ell");
6303     static const struct StringFindTest
6304     {
6305         const wxChar *str;
6306         size_t        start,
6307                       result;   // of searching "ell" in str
6308     } findTestData[] =
6309     {
6310         { _T("Well, hello world"),  0, 1 },
6311         { _T("Well, hello world"),  6, 7 },
6312         { _T("Well, hello world"),  9, wxString::npos },
6313     };
6314
6315     for ( size_t n = 0; n < WXSIZEOF(findTestData); n++ )
6316     {
6317         const StringFindTest& ft = findTestData[n];
6318         size_t res = wxString(ft.str).find(strToFind, ft.start);
6319
6320         wxPrintf(_T("Index of '%s' in '%s' starting from %u is %s "),
6321                strToFind, ft.str, ft.start, PosToString(res).c_str());
6322
6323         size_t resTrue = ft.result;
6324         if ( res == resTrue )
6325         {
6326             wxPuts(_T("(ok)"));
6327         }
6328         else
6329         {
6330             wxPrintf(_T("(ERROR: should be %s)\n"),
6331                    PosToString(resTrue).c_str());
6332         }
6333     }
6334
6335     wxPuts(_T(""));
6336 }
6337
6338 static void TestStringTokenizer()
6339 {
6340     wxPuts(_T("*** Testing wxStringTokenizer ***"));
6341
6342     static const wxChar *modeNames[] =
6343     {
6344         _T("default"),
6345         _T("return empty"),
6346         _T("return all empty"),
6347         _T("with delims"),
6348         _T("like strtok"),
6349     };
6350
6351     static const struct StringTokenizerTest
6352     {
6353         const wxChar *str;              // string to tokenize
6354         const wxChar *delims;           // delimiters to use
6355         size_t        count;            // count of token
6356         wxStringTokenizerMode mode;     // how should we tokenize it
6357     } tokenizerTestData[] =
6358     {
6359         { _T(""), _T(" "), 0 },
6360         { _T("Hello, world"), _T(" "), 2 },
6361         { _T("Hello,   world  "), _T(" "), 2 },
6362         { _T("Hello, world"), _T(","), 2 },
6363         { _T("Hello, world!"), _T(",!"), 2 },
6364         { _T("Hello,, world!"), _T(",!"), 3 },
6365         { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL },
6366         { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
6367         { _T("1 \t3\t4  6   "), wxDEFAULT_DELIMITERS, 4 },
6368         { _T("1 \t3\t4  6   "), wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY },
6369         { _T("1 \t3\t4  6   "), wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL },
6370         { _T("01/02/99"), _T("/-"), 3 },
6371         { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS },
6372     };
6373
6374     for ( size_t n = 0; n < WXSIZEOF(tokenizerTestData); n++ )
6375     {
6376         const StringTokenizerTest& tt = tokenizerTestData[n];
6377         wxStringTokenizer tkz(tt.str, tt.delims, tt.mode);
6378
6379         size_t count = tkz.CountTokens();
6380         wxPrintf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
6381                MakePrintable(tt.str).c_str(),
6382                count,
6383                MakePrintable(tt.delims).c_str(),
6384                modeNames[tkz.GetMode()]);
6385         if ( count == tt.count )
6386         {
6387             wxPuts(_T("(ok)"));
6388         }
6389         else
6390         {
6391             wxPrintf(_T("(ERROR: should be %u)\n"), tt.count);
6392
6393             continue;
6394         }
6395
6396         // if we emulate strtok(), check that we do it correctly
6397         wxChar *buf, *s = NULL, *last;
6398
6399         if ( tkz.GetMode() == wxTOKEN_STRTOK )
6400         {
6401             buf = new wxChar[wxStrlen(tt.str) + 1];
6402             wxStrcpy(buf, tt.str);
6403
6404             s = wxStrtok(buf, tt.delims, &last);
6405         }
6406         else
6407         {
6408             buf = NULL;
6409         }
6410
6411         // now show the tokens themselves
6412         size_t count2 = 0;
6413         while ( tkz.HasMoreTokens() )
6414         {
6415             wxString token = tkz.GetNextToken();
6416
6417             wxPrintf(_T("\ttoken %u: '%s'"),
6418                    ++count2,
6419                    MakePrintable(token).c_str());
6420
6421             if ( buf )
6422             {
6423                 if ( token == s )
6424                 {
6425                     wxPuts(_T(" (ok)"));
6426                 }
6427                 else
6428                 {
6429                     wxPrintf(_T(" (ERROR: should be %s)\n"), s);
6430                 }
6431
6432                 s = wxStrtok(NULL, tt.delims, &last);
6433             }
6434             else
6435             {
6436                 // nothing to compare with
6437                 wxPuts(_T(""));
6438             }
6439         }
6440
6441         if ( count2 != count )
6442         {
6443             wxPuts(_T("\tERROR: token count mismatch"));
6444         }
6445
6446         delete [] buf;
6447     }
6448
6449     wxPuts(_T(""));
6450 }
6451
6452 static void TestStringReplace()
6453 {
6454     wxPuts(_T("*** Testing wxString::replace ***"));
6455
6456     static const struct StringReplaceTestData
6457     {
6458         const wxChar *original;     // original test string
6459         size_t start, len;          // the part to replace
6460         const wxChar *replacement;  // the replacement string
6461         const wxChar *result;       // and the expected result
6462     } stringReplaceTestData[] =
6463     {
6464         { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
6465         { _T("increase"), 0, 2, _T("de"), _T("decrease") },
6466         { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
6467         { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
6468         { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
6469     };
6470
6471     for ( size_t n = 0; n < WXSIZEOF(stringReplaceTestData); n++ )
6472     {
6473         const StringReplaceTestData data = stringReplaceTestData[n];
6474
6475         wxString original = data.original;
6476         original.replace(data.start, data.len, data.replacement);
6477
6478         wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
6479                  data.original, data.start, data.len, data.replacement,
6480                  original.c_str());
6481
6482         if ( original == data.result )
6483         {
6484             wxPuts(_T("(ok)"));
6485         }
6486         else
6487         {
6488             wxPrintf(_T("(ERROR: should be '%s')\n"), data.result);
6489         }
6490     }
6491
6492     wxPuts(_T(""));
6493 }
6494
6495 static void TestStringMatch()
6496 {
6497     wxPuts(_T("*** Testing wxString::Matches() ***"));
6498
6499     static const struct StringMatchTestData
6500     {
6501         const wxChar *text;
6502         const wxChar *wildcard;
6503         bool matches;
6504     } stringMatchTestData[] =
6505     {
6506         { _T("foobar"), _T("foo*"), 1 },
6507         { _T("foobar"), _T("*oo*"), 1 },
6508         { _T("foobar"), _T("*bar"), 1 },
6509         { _T("foobar"), _T("??????"), 1 },
6510         { _T("foobar"), _T("f??b*"), 1 },
6511         { _T("foobar"), _T("f?b*"), 0 },
6512         { _T("foobar"), _T("*goo*"), 0 },
6513         { _T("foobar"), _T("*foo"), 0 },
6514         { _T("foobarfoo"), _T("*foo"), 1 },
6515         { _T(""), _T("*"), 1 },
6516         { _T(""), _T("?"), 0 },
6517     };
6518
6519     for ( size_t n = 0; n < WXSIZEOF(stringMatchTestData); n++ )
6520     {
6521         const StringMatchTestData& data = stringMatchTestData[n];
6522         bool matches = wxString(data.text).Matches(data.wildcard);
6523         wxPrintf(_T("'%s' %s '%s' (%s)\n"),
6524                  data.wildcard,
6525                  matches ? _T("matches") : _T("doesn't match"),
6526                  data.text,
6527                  matches == data.matches ? _T("ok") : _T("ERROR"));
6528     }
6529
6530     wxPuts(_T(""));
6531 }
6532
6533 // Sigh, I want Test::Simple, Test::More and Test::Harness...
6534 void ok(int line, bool ok, const wxString& msg = wxEmptyString)
6535 {
6536     if( !ok )
6537         wxPuts(_T("NOT OK: (") + wxString::Format(_T("%d"), line) +
6538                _T(") ") + msg);
6539 }
6540
6541 void is(int line, const wxString& got, const wxString& expected,
6542         const wxString& msg = wxEmptyString)
6543 {
6544     bool isOk = got == expected;
6545     ok(line, isOk, msg);
6546     if( !isOk )
6547     {
6548         wxPuts(_T("Got: ") + got);
6549         wxPuts(_T("Expected: ") + expected);
6550     }
6551 }
6552
6553 #if 0
6554 void is(int line, const wxChar* got, const wxChar* expected,
6555         const wxString& msg = wxEmptyString)
6556 {
6557     bool isOk = wxStrcmp( got, expected ) == 0;
6558     ok(line, isOk, msg);
6559     if( !isOk )
6560     {
6561         wxPuts(_T("Got: ") + wxString(got));
6562         wxPuts(_T("Expected: ") + wxString(expected));
6563     }
6564 }
6565 #endif
6566
6567 void is(int line, const wxChar& got, const wxChar& expected,
6568         const wxString& msg = wxEmptyString)
6569 {
6570     bool isOk = got == expected;
6571     ok(line, isOk, msg);
6572     if( !isOk )
6573     {
6574         wxPuts(_T("Got: ") + got);
6575         wxPuts(_T("Expected: ") + expected);
6576     }
6577 }
6578
6579 void is(int line, size_t got, size_t expected,
6580         const wxString& msg = wxEmptyString)
6581 {
6582     bool isOk = got == expected;
6583     ok(line, isOk, msg);
6584     if( !isOk )
6585     {
6586         wxPuts(wxString::Format(_T("Got: %ld"), got));
6587         wxPuts(wxString::Format(_T("Expected: %ld"), expected));
6588     }
6589 }
6590
6591 #define is_m( got, expected, message ) is( __LINE__, (got), (expected), (message) )
6592 #define is_nom( got, expected ) is( __LINE__, (got), (expected), wxEmptyString )
6593
6594 void TestStdString()
6595 {
6596     wxPuts(_T("*** Testing std::string operations ***\n"));
6597
6598     // test ctors
6599     wxString s1(_T("abcdefgh")),
6600              s2(_T("abcdefghijklm"), 8),
6601              s3(_T("abcdefghijklm")),
6602              s4(8, _T('a'));
6603     wxString s5(s1),
6604              s6(s3, 0, 8),
6605              s7(s3.begin(), s3.begin() + 8);
6606     wxString s8(s1, 4, 8), s9, s10, s11;
6607
6608     is( __LINE__, s1, _T("abcdefgh") );
6609     is( __LINE__, s2, s1 );
6610     is( __LINE__, s4, _T("aaaaaaaa") );
6611     is( __LINE__, s5, _T("abcdefgh") );
6612     is( __LINE__, s6, s1 );
6613     is( __LINE__, s7, s1 );
6614     is( __LINE__, s8, _T("efgh") );
6615
6616     // test append
6617     s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("abc");
6618     s1.append(_T("def"));
6619     s2.append(_T("defgh"), 3);
6620     s3.append(wxString(_T("abcdef")), 3, 6);
6621     s4.append(s1);
6622     s5.append(3, _T('a'));
6623     s6.append(s1.begin() + 3, s1.end());
6624
6625     is( __LINE__, s1, _T("abcdef") );
6626     is( __LINE__, s2, _T("abcdef") );
6627     is( __LINE__, s3, _T("abcdef") );
6628     is( __LINE__, s4, _T("abcabcdef") );
6629     is( __LINE__, s5, _T("abcaaa") );
6630     is( __LINE__, s6, _T("abcdef") );
6631
6632     // test assign
6633     s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("abc");
6634     s1.assign(_T("def"));
6635     s2.assign(_T("defgh"), 3);
6636     s3.assign(wxString(_T("abcdef")), 3, 6);
6637     s4.assign(s1);
6638     s5.assign(3, _T('a'));
6639     s6.assign(s1.begin() + 1, s1.end());
6640
6641     is( __LINE__, s1, _T("def") );
6642     is( __LINE__, s2, _T("def") );
6643     is( __LINE__, s3, _T("def") );
6644     is( __LINE__, s4, _T("def") );
6645     is( __LINE__, s5, _T("aaa") );
6646     is( __LINE__, s6, _T("ef") );
6647
6648     // test compare
6649     s1 = _T("abcdefgh");
6650     s2 = _T("abcdefgh");
6651     s3 = _T("abc");
6652     s4 = _T("abcdefghi");
6653     s5 = _T("aaa");
6654     s6 = _T("zzz");
6655     s7 = _T("zabcdefg");
6656
6657     ok( __LINE__, s1.compare(s2) == 0 );
6658     ok( __LINE__, s1.compare(s3) > 0 );
6659     ok( __LINE__, s1.compare(s4) < 0 );
6660     ok( __LINE__, s1.compare(s5) > 0 );
6661     ok( __LINE__, s1.compare(s6) < 0 );
6662     ok( __LINE__, s1.compare(1, 12, s1) > 0);
6663     ok( __LINE__, s1.compare(_T("abcdefgh")) == 0);
6664     ok( __LINE__, s1.compare(1, 7, _T("bcdefgh")) == 0);
6665     ok( __LINE__, s1.compare(1, 7, _T("bcdefgh"), 7) == 0);
6666
6667     // test erase
6668     s1.erase(1, 1);
6669     s2.erase(4, 12);
6670     wxString::iterator it = s3.erase(s3.begin() + 1);
6671     wxString::iterator it2 = s4.erase(s4.begin() + 4, s4.begin() + 6);
6672     wxString::iterator it3 = s7.erase(s7.begin() + 4, s7.begin() + 8);
6673
6674     is( __LINE__, s1, _T("acdefgh") );
6675     is( __LINE__, s2, _T("abcd") );
6676     is( __LINE__, s3, _T("ac") );
6677     is( __LINE__, s4, _T("abcdghi") );
6678     is( __LINE__, s7, _T("zabc") );
6679     is( __LINE__, *it, _T('c') );
6680     is( __LINE__, *it2, _T('g') );
6681     ok( __LINE__, it3 == s7.end() );
6682
6683     // find
6684     //       0         1         2
6685     //       01234567890123456789012345
6686     s1 = _T("abcdefgABCDEFGabcABCabcABC");
6687     s2 = _T("gAB");
6688
6689     is_nom( s1.find(_T('A')), 7u );
6690     is_nom( s1.find(_T('A'), 7), 7u );
6691     is_nom( s1.find(_T('Z')), wxString::npos );
6692     is_nom( s1.find(_T('C'), 22), 25u );
6693
6694     is_nom( s1.find(_T("gAB")), 6u );
6695     is_nom( s1.find(_T("gAB"), 7), wxString::npos );
6696     is_nom( s1.find(_T("gAB"), 6), 6u );
6697
6698     is_nom( s1.find(_T("gABZZZ"), 2, 3), 6u );
6699     is_nom( s1.find(_T("gABZZZ"), 7, 3), wxString::npos );
6700
6701     is_nom( s1.find(s2), 6u );
6702     is_nom( s1.find(s2, 7), wxString::npos );
6703     is_nom( s1.find(s2, 6), 6u );
6704
6705     // find_first_not_of
6706     //       0         1         2         3
6707     //       01234567890123456789012345678901234
6708     s1 = _T("aaaaaabcdefghlkjiaaaaaabcdbcdbcdbcd");
6709     s2 = _T("aaaaaa");
6710
6711     is_nom( s1.find_first_not_of(_T('a')), 6u );
6712     is_nom( s1.find_first_not_of(_T('a'), 7), 7u );
6713     is_nom( s2.find_first_not_of(_T('a')), wxString::npos );
6714
6715     is_nom( s1.find_first_not_of(_T("abde"), 4), 7u );
6716     is_nom( s1.find_first_not_of(_T("abde"), 7), 7u );
6717     is_nom( s1.find_first_not_of(_T("abcdefghijkl")), wxString::npos );
6718
6719     is_nom( s1.find_first_not_of(_T("abcdefghi"), 0, 4), 9u );
6720
6721     // find_first_of
6722     is_nom( s1.find_first_of(_T('c')), 7u );
6723     is_nom( s1.find_first_of(_T('v')), wxString::npos );
6724     is_nom( s1.find_first_of(_T('c'), 10), 24u );
6725
6726     is_nom( s1.find_first_of(_T("ijkl")), 13u );
6727     is_nom( s1.find_first_of(_T("ddcfg"), 17), 24u );
6728     is_nom( s1.find_first_of(_T("ddcfga"), 17, 5), 24u );
6729
6730     // find_last_not_of
6731     //       0         1         2         3
6732     //       01234567890123456789012345678901234
6733     s1 = _T("aaaaaabcdefghlkjiaaaaaabcdbcdbcdbcd");
6734     s2 = _T("aaaaaa");
6735
6736     is_nom( s2.find_last_not_of(_T('a')), wxString::npos );
6737     is_nom( s1.find_last_not_of(_T('d')), 33u );
6738     is_nom( s1.find_last_not_of(_T('d'), 25), 24u );
6739
6740     is_nom( s1.find_last_not_of(_T("bcd")), 22u );
6741     is_nom( s1.find_last_not_of(_T("abc"), 24), 16u );
6742
6743     is_nom( s1.find_last_not_of(_T("abcdefghijklmnopqrstuv"), 24, 3), 16u );
6744
6745     // find_last_of
6746     is_nom( s2.find_last_of(_T('c')), wxString::npos );
6747     is_nom( s1.find_last_of(_T('a')), 22u );
6748     is_nom( s1.find_last_of(_T('b'), 24), 23u );
6749
6750     is_nom( s1.find_last_of(_T("ijklm")), 16u );
6751     is_nom( s1.find_last_of(_T("ijklma"), 33, 4), 16u );
6752     is_nom( s1.find_last_of(_T("a"), 17), 17u );
6753
6754     // test insert
6755     s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("aaaa");
6756     s9 = s10 = _T("cdefg");
6757
6758     s1.insert(1, _T("cc") );
6759     s2.insert(2, _T("cdef"), 3);
6760     s3.insert(2, s10);
6761     s4.insert(2, s10, 3, 7);
6762     s5.insert(1, 2, _T('c'));
6763     it = s6.insert(s6.begin() + 3, _T('X'));
6764     s7.insert(s7.begin(), s9.begin(), s9.end() - 1);
6765     s8.insert(s8.begin(), 2, _T('c'));
6766
6767     is( __LINE__, s1, _T("accaaa") );
6768     is( __LINE__, s2, _T("aacdeaa") );
6769     is( __LINE__, s3, _T("aacdefgaa") );
6770     is( __LINE__, s4, _T("aafgaa") );
6771     is( __LINE__, s5, _T("accaaa") );
6772     is( __LINE__, s6, _T("aaaXa") );
6773     is( __LINE__, s7, _T("cdefaaaa") );
6774     is( __LINE__, s8, _T("ccaaaa") );
6775
6776     s1 = s2 = s3 = _T("aaaa");
6777     s1.insert(0, _T("ccc"), 2);
6778     s2.insert(4, _T("ccc"), 2);
6779
6780     is( __LINE__, s1, _T("ccaaaa") );
6781     is( __LINE__, s2, _T("aaaacc") );
6782
6783     // test replace
6784     s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = _T("QWERTYUIOP");
6785     s9 = s10 = _T("werty");
6786
6787     s1.replace(3, 4, _T("rtyu"));
6788     s1.replace(8, 7, _T("opopop"));
6789     s2.replace(10, 12, _T("WWWW"));
6790     s3.replace(1, 5, s9);
6791     s4.replace(1, 4, s9, 0, 4);
6792     s5.replace(1, 2, s9, 1, 12);
6793     s6.replace(0, 123, s9, 0, 123);
6794     s7.replace(2, 7, s9);
6795
6796     is( __LINE__, s1, _T("QWErtyuIopopop") );
6797     is( __LINE__, s2, _T("QWERTYUIOPWWWW") );
6798     is( __LINE__, s3, _T("QwertyUIOP") );
6799     is( __LINE__, s4, _T("QwertYUIOP") );
6800     is( __LINE__, s5, _T("QertyRTYUIOP") );
6801     is( __LINE__, s6, s9);
6802     is( __LINE__, s7, _T("QWwertyP") );
6803
6804     // rfind
6805     //       0         1         2
6806     //       01234567890123456789012345
6807     s1 = _T("abcdefgABCDEFGabcABCabcABC");
6808     s2 = _T("gAB");
6809     s3 = _T("ab");
6810
6811     is_nom( s1.rfind(_T('A')), 23u );
6812     is_nom( s1.rfind(_T('A'), 7), 7u );
6813     is_nom( s1.rfind(_T('Z')), wxString::npos );
6814     is_nom( s1.rfind(_T('C'), 22), 19u );
6815
6816     is_nom( s1.rfind(_T("cAB")), 22u );
6817     is_nom( s1.rfind(_T("cAB"), 15), wxString::npos );
6818     is_nom( s1.rfind(_T("cAB"), 21), 16u );
6819
6820     is_nom( s1.rfind(_T("gABZZZ"), 7, 3), 6u );
6821     is_nom( s1.rfind(_T("gABZZZ"), 5, 3), wxString::npos );
6822
6823     is_nom( s1.rfind(s2), 6u );
6824     is_nom( s1.rfind(s2, 5), wxString::npos );
6825     is_nom( s1.rfind(s2, 6), 6u );
6826     is_nom( s1.rfind(s3, 1), 0u );
6827
6828     // resize
6829     s1 = s2 = s3 = s4 = _T("abcABCdefDEF");
6830
6831     s1.resize( 12 );
6832     s2.resize( 10 );
6833     s3.resize( 14, _T(' ') );
6834     s4.resize( 14, _T('W') );
6835
6836     is_nom( s1, _T("abcABCdefDEF") );
6837     is_nom( s2, _T("abcABCdefD") );
6838     is_nom( s3, _T("abcABCdefDEF  ") );
6839     is_nom( s4, _T("abcABCdefDEFWW") );
6840
6841     // substr
6842     s1 = _T("abcdefgABCDEFG");
6843
6844     is_nom( s1.substr( 0, 14 ), s1 );
6845     is_nom( s1.substr( 1, 13 ), _T("bcdefgABCDEFG") );
6846     is_nom( s1.substr( 1, 20 ), _T("bcdefgABCDEFG") );
6847     is_nom( s1.substr( 14, 30 ), _T("") );
6848
6849     wxPuts(_T("*** Testing std::string operations finished ***\n"));
6850 }
6851
6852 #endif // TEST_STRINGS
6853
6854 // ----------------------------------------------------------------------------
6855 // entry point
6856 // ----------------------------------------------------------------------------
6857
6858 #ifdef TEST_SNGLINST
6859     #include "wx/snglinst.h"
6860 #endif // TEST_SNGLINST
6861
6862 int main(int argc, char **argv)
6863 {
6864     wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
6865
6866     wxInitializer initializer;
6867     if ( !initializer )
6868     {
6869         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
6870
6871         return -1;
6872     }
6873
6874 #ifdef TEST_SNGLINST
6875     wxSingleInstanceChecker checker;
6876     if ( checker.Create(_T(".wxconsole.lock")) )
6877     {
6878         if ( checker.IsAnotherRunning() )
6879         {
6880             wxPrintf(_T("Another instance of the program is running, exiting.\n"));
6881
6882             return 1;
6883         }
6884
6885         // wait some time to give time to launch another instance
6886         wxPrintf(_T("Press \"Enter\" to continue..."));
6887         wxFgetc(stdin);
6888     }
6889     else // failed to create
6890     {
6891         wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
6892     }
6893 #endif // TEST_SNGLINST
6894
6895 #ifdef TEST_CHARSET
6896     TestCharset();
6897 #endif // TEST_CHARSET
6898
6899 #ifdef TEST_CMDLINE
6900     TestCmdLineConvert();
6901
6902 #if wxUSE_CMDLINE_PARSER
6903     static const wxCmdLineEntryDesc cmdLineDesc[] =
6904     {
6905         { wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
6906             wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
6907         { wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
6908         { wxCMD_LINE_SWITCH, _T("q"), _T("quiet"),   _T("be quiet") },
6909
6910         { wxCMD_LINE_OPTION, _T("o"), _T("output"),  _T("output file") },
6911         { wxCMD_LINE_OPTION, _T("i"), _T("input"),   _T("input dir") },
6912         { wxCMD_LINE_OPTION, _T("s"), _T("size"),    _T("output block size"),
6913             wxCMD_LINE_VAL_NUMBER },
6914         { wxCMD_LINE_OPTION, _T("d"), _T("date"),    _T("output file date"),
6915             wxCMD_LINE_VAL_DATE },
6916
6917         { wxCMD_LINE_PARAM,  NULL, NULL, _T("input file"),
6918             wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
6919
6920         { wxCMD_LINE_NONE }
6921     };
6922
6923 #if wxUSE_UNICODE
6924     wxChar **wargv = new wxChar *[argc + 1];
6925
6926     {
6927         int n;
6928
6929         for (n = 0; n < argc; n++ )
6930         {
6931             wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
6932             wargv[n] = wxStrdup(warg);
6933         }
6934
6935         wargv[n] = NULL;
6936     }
6937
6938     #define argv wargv
6939 #endif // wxUSE_UNICODE
6940
6941     wxCmdLineParser parser(cmdLineDesc, argc, argv);
6942
6943 #if wxUSE_UNICODE
6944     {
6945         for ( int n = 0; n < argc; n++ )
6946             free(wargv[n]);
6947
6948         delete [] wargv;
6949     }
6950 #endif // wxUSE_UNICODE
6951
6952     parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
6953                      wxCMD_LINE_VAL_STRING,
6954                      wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
6955
6956     switch ( parser.Parse() )
6957     {
6958         case -1:
6959             wxLogMessage(_T("Help was given, terminating."));
6960             break;
6961
6962         case 0:
6963             ShowCmdLine(parser);
6964             break;
6965
6966         default:
6967             wxLogMessage(_T("Syntax error detected, aborting."));
6968             break;
6969     }
6970 #endif // wxUSE_CMDLINE_PARSER
6971
6972 #endif // TEST_CMDLINE
6973
6974 #ifdef TEST_STRINGS
6975     if ( TEST_ALL )
6976     {
6977         TestPChar();
6978         TestString();
6979         TestStringSub();
6980         TestStringConstruction();
6981         TestStringFormat();
6982         TestStringFind();
6983         TestStringTokenizer();
6984         TestStringReplace();
6985     }
6986     else
6987     {
6988         TestStringMatch();
6989     }
6990
6991     TestStdString();
6992 #endif // TEST_STRINGS
6993
6994 #ifdef TEST_ARRAYS
6995     if ( 1 || TEST_ALL )
6996     {
6997         wxArrayString a1;
6998         a1.Add(_T("tiger"));
6999         a1.Add(_T("cat"));
7000         a1.Add(_T("lion"), 3);
7001         a1.Add(_T("dog"));
7002         a1.Add(_T("human"));
7003         a1.Add(_T("ape"));
7004
7005         wxPuts(_T("*** Initially:"));
7006
7007         PrintArray(_T("a1"), a1);
7008
7009         wxArrayString a2(a1);
7010         PrintArray(_T("a2"), a2);
7011
7012 #if !wxUSE_STL
7013         wxSortedArrayString a3(a1);
7014 #else
7015         wxSortedArrayString a3;
7016         for (wxArrayString::iterator it = a1.begin(), en = a1.end();
7017              it != en; ++it)
7018             a3.Add(*it);
7019 #endif
7020         PrintArray(_T("a3"), a3);
7021
7022         wxPuts(_T("*** After deleting three strings from a1"));
7023         a1.RemoveAt(2,3);
7024
7025         PrintArray(_T("a1"), a1);
7026         PrintArray(_T("a2"), a2);
7027         PrintArray(_T("a3"), a3);
7028
7029 #if !wxUSE_STL
7030         wxPuts(_T("*** After reassigning a1 to a2 and a3"));
7031         a3 = a2 = a1;
7032         PrintArray(_T("a2"), a2);
7033         PrintArray(_T("a3"), a3);
7034 #endif
7035
7036         wxPuts(_T("*** After sorting a1"));
7037         a1.Sort(false);
7038         PrintArray(_T("a1"), a1);
7039
7040         wxPuts(_T("*** After sorting a1 in reverse order"));
7041         a1.Sort(true);
7042         PrintArray(_T("a1"), a1);
7043
7044 #if !wxUSE_STL
7045         wxPuts(_T("*** After sorting a1 by the string length"));
7046         a1.Sort(&StringLenCompare);
7047         PrintArray(_T("a1"), a1);
7048 #endif
7049
7050         TestArrayOfObjects();
7051         TestArrayOfUShorts();
7052     }
7053
7054     TestArrayOfInts();
7055     TestStlArray();
7056 #endif // TEST_ARRAYS
7057
7058 #ifdef TEST_DIR
7059     if ( TEST_ALL )
7060     {
7061         TestDirExists();
7062         TestDirEnum();
7063     }
7064     TestDirTraverse();
7065 #endif // TEST_DIR
7066
7067 #ifdef TEST_DLLLOADER
7068     TestDllLoad();
7069 #endif // TEST_DLLLOADER
7070
7071 #ifdef TEST_ENVIRON
7072     TestEnvironment();
7073 #endif // TEST_ENVIRON
7074
7075 #ifdef TEST_EXECUTE
7076     TestExecute();
7077 #endif // TEST_EXECUTE
7078
7079 #ifdef TEST_FILECONF
7080     TestFileConfRead();
7081 #endif // TEST_FILECONF
7082
7083 #ifdef TEST_LIST
7084     TestListCtor();
7085     TestList();
7086 #endif // TEST_LIST
7087
7088 #ifdef TEST_LOCALE
7089     TestDefaultLang();
7090 #endif // TEST_LOCALE
7091
7092 #ifdef TEST_LOG
7093     wxPuts(_T("*** Testing wxLog ***"));
7094
7095     wxString s;
7096     for ( size_t n = 0; n < 8000; n++ )
7097     {
7098         s << (wxChar)(_T('A') + (n % 26));
7099     }
7100
7101     wxLogWarning(_T("The length of the string is %lu"),
7102                  (unsigned long)s.length());
7103
7104     wxString msg;
7105     msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
7106
7107     // this one shouldn't be truncated
7108     wxPrintf(msg);
7109
7110     // but this one will because log functions use fixed size buffer
7111     // (note that it doesn't need '\n' at the end neither - will be added
7112     //  by wxLog anyhow)
7113     wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
7114 #endif // TEST_LOG
7115
7116 #ifdef TEST_FILE
7117     if ( TEST_ALL )
7118     {
7119         TestFileRead();
7120         TestTextFileRead();
7121         TestFileCopy();
7122     }
7123 #endif // TEST_FILE
7124
7125 #ifdef TEST_FILENAME
7126     if ( 0 )
7127     {
7128         wxFileName fn;
7129         fn.Assign(_T("c:\\foo"), _T("bar.baz"));
7130         fn.Assign(_T("/u/os9-port/Viewer/tvision/WEI2HZ-3B3-14_05-04-00MSC1.asc"));
7131
7132         DumpFileName(fn);
7133     }
7134
7135     TestFileNameConstruction();
7136     if ( TEST_ALL )
7137     {
7138         TestFileNameConstruction();
7139         TestFileNameMakeRelative();
7140         TestFileNameMakeAbsolute();
7141         TestFileNameSplit();
7142         TestFileNameTemp();
7143         TestFileNameCwd();
7144         TestFileNameComparison();
7145         TestFileNameOperations();
7146     }
7147 #endif // TEST_FILENAME
7148
7149 #ifdef TEST_FILETIME
7150     TestFileGetTimes();
7151     if ( 0 )
7152     TestFileSetTimes();
7153 #endif // TEST_FILETIME
7154
7155 #ifdef TEST_FTP
7156     wxLog::AddTraceMask(FTP_TRACE_MASK);
7157     if ( TestFtpConnect() )
7158     {
7159         if ( TEST_ALL )
7160         {
7161             TestFtpList();
7162             TestFtpDownload();
7163             TestFtpMisc();
7164             TestFtpFileSize();
7165             TestFtpUpload();
7166         }
7167
7168         if ( TEST_INTERACTIVE )
7169             TestFtpInteractive();
7170     }
7171     //else: connecting to the FTP server failed
7172
7173     if ( 0 )
7174         TestFtpWuFtpd();
7175 #endif // TEST_FTP
7176
7177 #ifdef TEST_LONGLONG
7178     // seed pseudo random generator
7179     srand((unsigned)time(NULL));
7180
7181     if ( 0 )
7182     {
7183         TestSpeed();
7184     }
7185
7186     if ( TEST_ALL )
7187     {
7188         TestMultiplication();
7189         TestDivision();
7190         TestAddition();
7191         TestLongLongConversion();
7192         TestBitOperations();
7193         TestLongLongComparison();
7194         TestLongLongToString();
7195         TestLongLongPrintf();
7196     }
7197 #endif // TEST_LONGLONG
7198
7199 #ifdef TEST_HASH
7200     TestHash();
7201 #endif // TEST_HASH
7202
7203 #ifdef TEST_HASHMAP
7204     TestHashMap();
7205 #endif // TEST_HASHMAP
7206
7207 #ifdef TEST_HASHSET
7208     TestHashSet();
7209 #endif // TEST_HASHSET
7210
7211 #ifdef TEST_MIME
7212     wxLog::AddTraceMask(_T("mime"));
7213     if ( TEST_ALL )
7214     {
7215         TestMimeEnum();
7216         TestMimeOverride();
7217         TestMimeAssociate();
7218     }
7219     TestMimeFilename();
7220 #endif // TEST_MIME
7221
7222 #ifdef TEST_INFO_FUNCTIONS
7223     if ( TEST_ALL )
7224     {
7225         TestOsInfo();
7226         TestUserInfo();
7227
7228         if ( TEST_INTERACTIVE )
7229             TestDiskInfo();
7230     }
7231 #endif // TEST_INFO_FUNCTIONS
7232
7233 #ifdef TEST_PATHLIST
7234     TestPathList();
7235 #endif // TEST_PATHLIST
7236
7237 #ifdef TEST_ODBC
7238     TestDbOpen();
7239 #endif // TEST_ODBC
7240
7241 #ifdef TEST_PRINTF
7242     TestPrintf();
7243 #endif // TEST_PRINTF
7244
7245 #ifdef TEST_REGCONF
7246     TestRegConfWrite();
7247 #endif // TEST_REGCONF
7248
7249 #ifdef TEST_REGEX
7250     // TODO: write a real test using src/regex/tests file
7251     if ( TEST_ALL )
7252     {
7253         TestRegExCompile();
7254         TestRegExMatch();
7255         TestRegExSubmatch();
7256         TestRegExReplacement();
7257
7258         if ( TEST_INTERACTIVE )
7259             TestRegExInteractive();
7260     }
7261 #endif // TEST_REGEX
7262
7263 #ifdef TEST_REGISTRY
7264     TestRegistryRead();
7265     TestRegistryAssociation();
7266 #endif // TEST_REGISTRY
7267
7268 #ifdef TEST_SOCKETS
7269     TestSocketServer();
7270     TestSocketClient();
7271 #endif // TEST_SOCKETS
7272
7273 #ifdef TEST_STREAMS
7274     if ( TEST_ALL )
7275     {
7276         TestFileStream();
7277     }
7278         TestMemoryStream();
7279 #endif // TEST_STREAMS
7280
7281 #ifdef TEST_TEXTSTREAM
7282     TestTextInputStream();
7283 #endif // TEST_TEXTSTREAM
7284
7285 #ifdef TEST_THREADS
7286     int nCPUs = wxThread::GetCPUCount();
7287     wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
7288     if ( nCPUs != -1 )
7289         wxThread::SetConcurrency(nCPUs);
7290
7291         TestDetachedThreads();
7292     if ( TEST_ALL )
7293     {
7294         TestJoinableThreads();
7295         TestThreadSuspend();
7296         TestThreadDelete();
7297         TestThreadConditions();
7298         TestThreadExec();
7299         TestSemaphore();
7300     }
7301 #endif // TEST_THREADS
7302
7303 #ifdef TEST_TIMER
7304     TestStopWatch();
7305 #endif // TEST_TIMER
7306
7307 #ifdef TEST_DATETIME
7308     if ( TEST_ALL )
7309     {
7310         TestTimeSet();
7311         TestTimeStatic();
7312         TestTimeRange();
7313         TestTimeZones();
7314         TestTimeTicks();
7315         TestTimeJDN();
7316         TestTimeDST();
7317         TestTimeWDays();
7318         TestTimeWNumber();
7319         TestTimeParse();
7320         TestTimeArithmetics();
7321         TestTimeHolidays();
7322         TestTimeFormat();
7323         TestTimeSpanFormat();
7324         TestTimeMS();
7325
7326         TestTimeZoneBug();
7327     }
7328
7329     TestTimeWNumber();
7330
7331     if ( TEST_INTERACTIVE )
7332         TestDateTimeInteractive();
7333 #endif // TEST_DATETIME
7334
7335 #ifdef TEST_SCOPEGUARD
7336     TestScopeGuard();
7337 #endif
7338
7339 #ifdef TEST_USLEEP
7340     wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
7341     wxUsleep(3000);
7342 #endif // TEST_USLEEP
7343
7344 #ifdef TEST_VCARD
7345     TestVCardRead();
7346     TestVCardWrite();
7347 #endif // TEST_VCARD
7348
7349 #ifdef TEST_VOLUME
7350     TestFSVolume();
7351 #endif // TEST_VOLUME
7352
7353 #ifdef TEST_UNICODE
7354     TestUnicodeToFromAscii();
7355 #endif // TEST_UNICODE
7356
7357 #ifdef TEST_WCHAR
7358     TestUtf8();
7359     TestEncodingConverter();
7360 #endif // TEST_WCHAR
7361
7362 #ifdef TEST_ZIP
7363     TestZipStreamRead();
7364     TestZipFileSystem();
7365 #endif // TEST_ZIP
7366
7367 #ifdef TEST_ZLIB
7368     TestZlibStreamWrite();
7369     TestZlibStreamRead();
7370 #endif // TEST_ZLIB
7371
7372     return 0;
7373 }
7374