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