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 <stdio.h>
  21
  22 #include <wx/string.h>
  23 #include <wx/file.h>
  24 #include <wx/app.h>
  25
  26 // without this pragma, the stupid compiler precompiles #defines below so that
  27 // changing them doesn't "take place" later!
  28 #ifdef __VISUALC__
  29     #pragma hdrstop
  30 #endif
  31
  32 // ----------------------------------------------------------------------------
  33 // conditional compilation
  34 // ----------------------------------------------------------------------------
  35
  36 // what to test (in alphabetic order)?
  37
  38 //#define TEST_ARRAYS
  39 //#define TEST_CHARSET
  40 //#define TEST_CMDLINE
  41 //#define TEST_DATETIME
  42 #define TEST_DIR
  43 //#define TEST_DLLLOADER
  44 //#define TEST_ENVIRON
  45 //#define TEST_EXECUTE
  46 //#define TEST_FILE
  47 //#define TEST_FILECONF
  48 //#define TEST_FILENAME
  49 //#define TEST_FTP
  50 //#define TEST_HASH
  51 //#define TEST_INFO_FUNCTIONS
  52 //#define TEST_LIST
  53 //#define TEST_LOCALE
  54 //#define TEST_LOG
  55 //#define TEST_LONGLONG
  56 //#define TEST_MIME
  57 //#define TEST_PATHLIST
  58 //#define TEST_REGCONF
  59 //#define TEST_REGISTRY
  60 //#define TEST_SOCKETS
  61 //#define TEST_STREAMS
  62 //#define TEST_STRINGS
  63 //#define TEST_THREADS
  64 //#define TEST_TIMER
  65 //#define TEST_VCARD            -- don't enable this (VZ)
  66 //#define TEST_WCHAR
  67 //#define TEST_ZIP
  68 //#define TEST_ZLIB
  69
  70 // ----------------------------------------------------------------------------
  71 // test class for container objects
  72 // ----------------------------------------------------------------------------
  73
  74 #if defined(TEST_ARRAYS) || defined(TEST_LIST)
  75
  76 class Bar // Foo is already taken in the hash test
  77 {
  78 public:
  79     Bar(const wxString& name) : m_name(name) { ms_bars++; }
  80    ~Bar() { ms_bars--; }
  81
  82    static size_t GetNumber() { return ms_bars; }
  83
  84    const char *GetName() const { return m_name; }
  85
  86 private:
  87    wxString m_name;
  88
  89    static size_t ms_bars;
  90 };
  91
  92 size_t Bar::ms_bars = 0;
  93
  94 #endif // defined(TEST_ARRAYS) || defined(TEST_LIST)
  95
  96 // ============================================================================
  97 // implementation
  98 // ============================================================================
  99
 100 // ----------------------------------------------------------------------------
 101 // helper functions
 102 // ----------------------------------------------------------------------------
 103
 104 #if defined(TEST_STRINGS) || defined(TEST_SOCKETS)
 105
 106 // replace TABs with \t and CRs with \n
 107 static wxString MakePrintable(const wxChar *s)
 108 {
 109     wxString str(s);
 110     (void)str.Replace(_T("\t"), _T("\\t"));
 111     (void)str.Replace(_T("\n"), _T("\\n"));
 112     (void)str.Replace(_T("\r"), _T("\\r"));
 113
 114     return str;
 115 }
 116
 117 #endif // MakePrintable() is used
 118
 119 // ----------------------------------------------------------------------------
 120 // wxFontMapper::CharsetToEncoding
 121 // ----------------------------------------------------------------------------
 122
 123 #ifdef TEST_CHARSET
 124
 125 #include <wx/fontmap.h>
 126
 127 static void TestCharset()
 128 {
 129     static const wxChar *charsets[] =
 130     {
 131         // some vali charsets
 132         _T("us-ascii    "),
 133         _T("iso8859-1   "),
 134         _T("iso-8859-12 "),
 135         _T("koi8-r      "),
 136         _T("utf-7       "),
 137         _T("cp1250      "),
 138         _T("windows-1252"),
 139
 140         // and now some bogus ones
 141         _T("            "),
 142         _T("cp1249      "),
 143         _T("iso--8859-1 "),
 144         _T("iso-8859-19 "),
 145     };
 146
 147     for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
 148     {
 149         wxFontEncoding enc = wxTheFontMapper->CharsetToEncoding(charsets[n]);
 150         wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
 151                  charsets[n],
 152                  wxTheFontMapper->GetEncodingName(enc).c_str(),
 153                  wxTheFontMapper->GetEncodingDescription(enc).c_str());
 154     }
 155 }
 156
 157 #endif // TEST_CHARSET
 158
 159 // ----------------------------------------------------------------------------
 160 // wxCmdLineParser
 161 // ----------------------------------------------------------------------------
 162
 163 #ifdef TEST_CMDLINE
 164
 165 #include <wx/cmdline.h>
 166 #include <wx/datetime.h>
 167
 168 static void ShowCmdLine(const wxCmdLineParser& parser)
 169 {
 170     wxString s = "Input files: ";
 171
 172     size_t count = parser.GetParamCount();
 173     for ( size_t param = 0; param < count; param++ )
 174     {
 175         s << parser.GetParam(param) << ' ';
 176     }
 177
 178     s << '\n'
 179       << "Verbose:\t" << (parser.Found("v") ? "yes" : "no") << '\n'
 180       << "Quiet:\t" << (parser.Found("q") ? "yes" : "no") << '\n';
 181
 182     wxString strVal;
 183     long lVal;
 184     wxDateTime dt;
 185     if ( parser.Found("o", &strVal) )
 186         s << "Output file:\t" << strVal << '\n';
 187     if ( parser.Found("i", &strVal) )
 188         s << "Input dir:\t" << strVal << '\n';
 189     if ( parser.Found("s", &lVal) )
 190         s << "Size:\t" << lVal << '\n';
 191     if ( parser.Found("d", &dt) )
 192         s << "Date:\t" << dt.FormatISODate() << '\n';
 193     if ( parser.Found("project_name", &strVal) )
 194         s << "Project:\t" << strVal << '\n';
 195
 196     wxLogMessage(s);
 197 }
 198
 199 #endif // TEST_CMDLINE
 200
 201 // ----------------------------------------------------------------------------
 202 // wxDir
 203 // ----------------------------------------------------------------------------
 204
 205 #ifdef TEST_DIR
 206
 207 #include <wx/dir.h>
 208
 209 #ifdef __UNIX__
 210     static const wxChar *ROOTDIR = _T("/");
 211     static const wxChar *TESTDIR = _T("/usr");
 212 #elif defined(__WXMSW__)
 213     static const wxChar *ROOTDIR = _T("c:\\");
 214     static const wxChar *TESTDIR = _T("d:\\");
 215 #else
 216     #error "don't know where the root directory is"
 217 #endif
 218
 219 static void TestDirEnumHelper(wxDir& dir,
 220                               int flags = wxDIR_DEFAULT,
 221                               const wxString& filespec = wxEmptyString)
 222 {
 223     wxString filename;
 224
 225     if ( !dir.IsOpened() )
 226         return;
 227
 228     bool cont = dir.GetFirst(&filename, filespec, flags);
 229     while ( cont )
 230     {
 231         printf("\t%s\n", filename.c_str());
 232
 233         cont = dir.GetNext(&filename);
 234     }
 235
 236     puts("");
 237 }
 238
 239 static void TestDirEnum()
 240 {
 241     puts("*** Testing wxDir::GetFirst/GetNext ***");
 242
 243     wxDir dir(wxGetCwd());
 244
 245     puts("Enumerating everything in current directory:");
 246     TestDirEnumHelper(dir);
 247
 248     puts("Enumerating really everything in current directory:");
 249     TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
 250
 251     puts("Enumerating object files in current directory:");
 252     TestDirEnumHelper(dir, wxDIR_DEFAULT, "*.o");
 253
 254     puts("Enumerating directories in current directory:");
 255     TestDirEnumHelper(dir, wxDIR_DIRS);
 256
 257     puts("Enumerating files in current directory:");
 258     TestDirEnumHelper(dir, wxDIR_FILES);
 259
 260     puts("Enumerating files including hidden in current directory:");
 261     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 262
 263     dir.Open(ROOTDIR);
 264
 265     puts("Enumerating everything in root directory:");
 266     TestDirEnumHelper(dir, wxDIR_DEFAULT);
 267
 268     puts("Enumerating directories in root directory:");
 269     TestDirEnumHelper(dir, wxDIR_DIRS);
 270
 271     puts("Enumerating files in root directory:");
 272     TestDirEnumHelper(dir, wxDIR_FILES);
 273
 274     puts("Enumerating files including hidden in root directory:");
 275     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 276
 277     puts("Enumerating files in non existing directory:");
 278     wxDir dirNo("nosuchdir");
 279     TestDirEnumHelper(dirNo);
 280 }
 281
 282 class DirPrintTraverser : public wxDirTraverser
 283 {
 284 public:
 285     virtual wxDirTraverseResult OnFile(const wxString& filename)
 286     {
 287         return wxDIR_CONTINUE;
 288     }
 289
 290     virtual wxDirTraverseResult OnDir(const wxString& dirname)
 291     {
 292         wxString path, name, ext;
 293         wxSplitPath(dirname, &path, &name, &ext);
 294
 295         if ( !ext.empty() )
 296             name << _T('.') << ext;
 297
 298         wxString indent;
 299         for ( const wxChar *p = path.c_str(); *p; p++ )
 300         {
 301             if ( wxIsPathSeparator(*p) )
 302                 indent += _T("    ");
 303         }
 304
 305         printf("%s%s\n", indent.c_str(), name.c_str());
 306
 307         return wxDIR_CONTINUE;
 308     }
 309 };
 310
 311 static void TestDirTraverse()
 312 {
 313     puts("*** Testing wxDir::Traverse() ***");
 314
 315     // enum all files
 316     wxArrayString files;
 317     size_t n = wxDir::GetAllFiles(TESTDIR, &files);
 318     printf("There are %u files under '%s'\n", n, TESTDIR);
 319     if ( n > 1 )
 320     {
 321         printf("First one is '%s'\n", files[0u]);
 322         printf(" last one is '%s'\n", files[n - 1]);
 323     }
 324
 325     // enum again with custom traverser
 326     wxDir dir(TESTDIR);
 327     DirPrintTraverser traverser;
 328     dir.Traverse(traverser, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
 329 }
 330
 331 #endif // TEST_DIR
 332
 333 // ----------------------------------------------------------------------------
 334 // wxDllLoader
 335 // ----------------------------------------------------------------------------
 336
 337 #ifdef TEST_DLLLOADER
 338
 339 #include <wx/dynlib.h>
 340
 341 static void TestDllLoad()
 342 {
 343 #if defined(__WXMSW__)
 344     static const wxChar *LIB_NAME = _T("kernel32.dll");
 345     static const wxChar *FUNC_NAME = _T("lstrlenA");
 346 #elif defined(__UNIX__)
 347     // weird: using just libc.so does *not* work!
 348     static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
 349     static const wxChar *FUNC_NAME = _T("strlen");
 350 #else
 351     #error "don't know how to test wxDllLoader on this platform"
 352 #endif
 353
 354     puts("*** testing wxDllLoader ***\n");
 355
 356     wxDllType dllHandle = wxDllLoader::LoadLibrary(LIB_NAME);
 357     if ( !dllHandle )
 358     {
 359         wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
 360     }
 361     else
 362     {
 363         typedef int (*strlenType)(char *);
 364         strlenType pfnStrlen = (strlenType)wxDllLoader::GetSymbol(dllHandle, FUNC_NAME);
 365         if ( !pfnStrlen )
 366         {
 367             wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
 368                      FUNC_NAME, LIB_NAME);
 369         }
 370         else
 371         {
 372             if ( pfnStrlen("foo") != 3 )
 373             {
 374                 wxPrintf(_T("ERROR: loaded function is not strlen()!\n"));
 375             }
 376             else
 377             {
 378                 puts("... ok");
 379             }
 380         }
 381
 382         wxDllLoader::UnloadLibrary(dllHandle);
 383     }
 384 }
 385
 386 #endif // TEST_DLLLOADER
 387
 388 // ----------------------------------------------------------------------------
 389 // wxGet/SetEnv
 390 // ----------------------------------------------------------------------------
 391
 392 #ifdef TEST_ENVIRON
 393
 394 #include <wx/utils.h>
 395
 396 static wxString MyGetEnv(const wxString& var)
 397 {
 398     wxString val;
 399     if ( !wxGetEnv(var, &val) )
 400         val = _T("<empty>");
 401     else
 402         val = wxString(_T('\'')) + val + _T('\'');
 403
 404     return val;
 405 }
 406
 407 static void TestEnvironment()
 408 {
 409     const wxChar *var = _T("wxTestVar");
 410
 411     puts("*** testing environment access functions ***");
 412
 413     printf("Initially getenv(%s) = %s\n", var, MyGetEnv(var).c_str());
 414     wxSetEnv(var, _T("value for wxTestVar"));
 415     printf("After wxSetEnv: getenv(%s) = %s\n",  var, MyGetEnv(var).c_str());
 416     wxSetEnv(var, _T("another value"));
 417     printf("After 2nd wxSetEnv: getenv(%s) = %s\n",  var, MyGetEnv(var).c_str());
 418     wxUnsetEnv(var);
 419     printf("After wxUnsetEnv: getenv(%s) = %s\n",  var, MyGetEnv(var).c_str());
 420     printf("PATH = %s\n",  MyGetEnv(_T("PATH")));
 421 }
 422
 423 #endif // TEST_ENVIRON
 424
 425 // ----------------------------------------------------------------------------
 426 // wxExecute
 427 // ----------------------------------------------------------------------------
 428
 429 #ifdef TEST_EXECUTE
 430
 431 #include <wx/utils.h>
 432
 433 static void TestExecute()
 434 {
 435     puts("*** testing wxExecute ***");
 436
 437 #ifdef __UNIX__
 438     #define COMMAND "cat -n ../../Makefile" // "echo hi"
 439     #define SHELL_COMMAND "echo hi from shell"
 440     #define REDIRECT_COMMAND COMMAND // "date"
 441 #elif defined(__WXMSW__)
 442     #define COMMAND "command.com -c 'echo hi'"
 443     #define SHELL_COMMAND "echo hi"
 444     #define REDIRECT_COMMAND COMMAND
 445 #else
 446     #error "no command to exec"
 447 #endif // OS
 448
 449     printf("Testing wxShell: ");
 450     fflush(stdout);
 451     if ( wxShell(SHELL_COMMAND) )
 452         puts("Ok.");
 453     else
 454         puts("ERROR.");
 455
 456     printf("Testing wxExecute: ");
 457     fflush(stdout);
 458     if ( wxExecute(COMMAND, TRUE /* sync */) == 0 )
 459         puts("Ok.");
 460     else
 461         puts("ERROR.");
 462
 463 #if 0 // no, it doesn't work (yet?)
 464     printf("Testing async wxExecute: ");
 465     fflush(stdout);
 466     if ( wxExecute(COMMAND) != 0 )
 467         puts("Ok (command launched).");
 468     else
 469         puts("ERROR.");
 470 #endif // 0
 471
 472     printf("Testing wxExecute with redirection:\n");
 473     wxArrayString output;
 474     if ( wxExecute(REDIRECT_COMMAND, output) != 0 )
 475     {
 476         puts("ERROR.");
 477     }
 478     else
 479     {
 480         size_t count = output.GetCount();
 481         for ( size_t n = 0; n < count; n++ )
 482         {
 483             printf("\t%s\n", output[n].c_str());
 484         }
 485
 486         puts("Ok.");
 487     }
 488 }
 489
 490 #endif // TEST_EXECUTE
 491
 492 // ----------------------------------------------------------------------------
 493 // file
 494 // ----------------------------------------------------------------------------
 495
 496 #ifdef TEST_FILE
 497
 498 #include <wx/file.h>
 499 #include <wx/ffile.h>
 500 #include <wx/textfile.h>
 501
 502 static void TestFileRead()
 503 {
 504     puts("*** wxFile read test ***");
 505
 506     wxFile file(_T("testdata.fc"));
 507     if ( file.IsOpened() )
 508     {
 509         printf("File length: %lu\n", file.Length());
 510
 511         puts("File dump:\n----------");
 512
 513         static const off_t len = 1024;
 514         char buf[len];
 515         for ( ;; )
 516         {
 517             off_t nRead = file.Read(buf, len);
 518             if ( nRead == wxInvalidOffset )
 519             {
 520                 printf("Failed to read the file.");
 521                 break;
 522             }
 523
 524             fwrite(buf, nRead, 1, stdout);
 525
 526             if ( nRead < len )
 527                 break;
 528         }
 529
 530         puts("----------");
 531     }
 532     else
 533     {
 534         printf("ERROR: can't open test file.\n");
 535     }
 536
 537     puts("");
 538 }
 539
 540 static void TestTextFileRead()
 541 {
 542     puts("*** wxTextFile read test ***");
 543
 544     wxTextFile file(_T("testdata.fc"));
 545     if ( file.Open() )
 546     {
 547         printf("Number of lines: %u\n", file.GetLineCount());
 548         printf("Last line: '%s'\n", file.GetLastLine().c_str());
 549
 550         wxString s;
 551
 552         puts("\nDumping the entire file:");
 553         for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
 554         {
 555             printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
 556         }
 557         printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
 558
 559         puts("\nAnd now backwards:");
 560         for ( s = file.GetLastLine();
 561               file.GetCurrentLine() != 0;
 562               s = file.GetPrevLine() )
 563         {
 564             printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
 565         }
 566         printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
 567     }
 568     else
 569     {
 570         printf("ERROR: can't open '%s'\n", file.GetName());
 571     }
 572
 573     puts("");
 574 }
 575
 576 static void TestFileCopy()
 577 {
 578     puts("*** Testing wxCopyFile ***");
 579
 580     static const wxChar *filename1 = _T("testdata.fc");
 581     static const wxChar *filename2 = _T("test2");
 582     if ( !wxCopyFile(filename1, filename2) )
 583     {
 584         puts("ERROR: failed to copy file");
 585     }
 586     else
 587     {
 588         wxFFile f1(filename1, "rb"),
 589                 f2(filename2, "rb");
 590
 591         if ( !f1.IsOpened() || !f2.IsOpened() )
 592         {
 593             puts("ERROR: failed to open file(s)");
 594         }
 595         else
 596         {
 597             wxString s1, s2;
 598             if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
 599             {
 600                 puts("ERROR: failed to read file(s)");
 601             }
 602             else
 603             {
 604                 if ( (s1.length() != s2.length()) ||
 605                      (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
 606                 {
 607                     puts("ERROR: copy error!");
 608                 }
 609                 else
 610                 {
 611                     puts("File was copied ok.");
 612                 }
 613             }
 614         }
 615     }
 616
 617     if ( !wxRemoveFile(filename2) )
 618     {
 619         puts("ERROR: failed to remove the file");
 620     }
 621
 622     puts("");
 623 }
 624
 625 #endif // TEST_FILE
 626
 627 // ----------------------------------------------------------------------------
 628 // wxFileConfig
 629 // ----------------------------------------------------------------------------
 630
 631 #ifdef TEST_FILECONF
 632
 633 #include <wx/confbase.h>
 634 #include <wx/fileconf.h>
 635
 636 static const struct FileConfTestData
 637 {
 638     const wxChar *name;      // value name
 639     const wxChar *value;     // the value from the file
 640 } fcTestData[] =
 641 {
 642     { _T("value1"),                       _T("one") },
 643     { _T("value2"),                       _T("two") },
 644     { _T("novalue"),                      _T("default") },
 645 };
 646
 647 static void TestFileConfRead()
 648 {
 649     puts("*** testing wxFileConfig loading/reading ***");
 650
 651     wxFileConfig fileconf(_T("test"), wxEmptyString,
 652                           _T("testdata.fc"), wxEmptyString,
 653                           wxCONFIG_USE_RELATIVE_PATH);
 654
 655     // test simple reading
 656     puts("\nReading config file:");
 657     wxString defValue(_T("default")), value;
 658     for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
 659     {
 660         const FileConfTestData& data = fcTestData[n];
 661         value = fileconf.Read(data.name, defValue);
 662         printf("\t%s = %s ", data.name, value.c_str());
 663         if ( value == data.value )
 664         {
 665             puts("(ok)");
 666         }
 667         else
 668         {
 669             printf("(ERROR: should be %s)\n", data.value);
 670         }
 671     }
 672
 673     // test enumerating the entries
 674     puts("\nEnumerating all root entries:");
 675     long dummy;
 676     wxString name;
 677     bool cont = fileconf.GetFirstEntry(name, dummy);
 678     while ( cont )
 679     {
 680         printf("\t%s = %s\n",
 681                name.c_str(),
 682                fileconf.Read(name.c_str(), _T("ERROR")).c_str());
 683
 684         cont = fileconf.GetNextEntry(name, dummy);
 685     }
 686 }
 687
 688 #endif // TEST_FILECONF
 689
 690 // ----------------------------------------------------------------------------
 691 // wxFileName
 692 // ----------------------------------------------------------------------------
 693
 694 #ifdef TEST_FILENAME
 695
 696 #include <wx/filename.h>
 697
 698 static struct FileNameInfo
 699 {
 700     const wxChar *fullname;
 701     const wxChar *path;
 702     const wxChar *name;
 703     const wxChar *ext;
 704 } filenames[] =
 705 {
 706     { _T("/usr/bin/ls"), _T("/usr/bin"), _T("ls"), _T("") },
 707     { _T("/usr/bin/"), _T("/usr/bin"), _T(""), _T("") },
 708     { _T("~/.zshrc"), _T("~"), _T(".zshrc"), _T("") },
 709     { _T("../../foo"), _T("../.."), _T("foo"), _T("") },
 710     { _T("foo.bar"), _T(""), _T("foo"), _T("bar") },
 711     { _T("~/foo.bar"), _T("~"), _T("foo"), _T("bar") },
 712     { _T("Mahogany-0.60/foo.bar"), _T("Mahogany-0.60"), _T("foo"), _T("bar") },
 713     { _T("/tmp/wxwin.tar.bz"), _T("/tmp"), _T("wxwin.tar"), _T("bz") },
 714 };
 715
 716 static void TestFileNameConstruction()
 717 {
 718     puts("*** testing wxFileName construction ***");
 719
 720     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
 721     {
 722         wxFileName fn(filenames[n].fullname, wxPATH_UNIX);
 723
 724         printf("Filename: '%s'\t", fn.GetFullPath().c_str());
 725         if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), wxPATH_UNIX) )
 726         {
 727             puts("ERROR (couldn't be normalized)");
 728         }
 729         else
 730         {
 731             printf("normalized: '%s'\n", fn.GetFullPath().c_str());
 732         }
 733     }
 734
 735     puts("");
 736 }
 737
 738 static void TestFileNameSplit()
 739 {
 740     puts("*** testing wxFileName splitting ***");
 741
 742     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
 743     {
 744         const FileNameInfo &fni = filenames[n];
 745         wxString path, name, ext;
 746         wxFileName::SplitPath(fni.fullname, &path, &name, &ext);
 747
 748         printf("%s -> path = '%s', name = '%s', ext = '%s'",
 749                fni.fullname, path.c_str(), name.c_str(), ext.c_str());
 750         if ( path != fni.path )
 751             printf(" (ERROR: path = '%s')", fni.path);
 752         if ( name != fni.name )
 753             printf(" (ERROR: name = '%s')", fni.name);
 754         if ( ext != fni.ext )
 755             printf(" (ERROR: ext = '%s')", fni.ext);
 756         puts("");
 757     }
 758
 759     puts("");
 760 }
 761
 762 static void TestFileNameComparison()
 763 {
 764     // TODO!
 765 }
 766
 767 static void TestFileNameOperations()
 768 {
 769     // TODO!
 770 }
 771
 772 static void TestFileNameCwd()
 773 {
 774     // TODO!
 775 }
 776
 777 #endif // TEST_FILENAME
 778
 779 // ----------------------------------------------------------------------------
 780 // wxHashTable
 781 // ----------------------------------------------------------------------------
 782
 783 #ifdef TEST_HASH
 784
 785 #include <wx/hash.h>
 786
 787 struct Foo
 788 {
 789     Foo(int n_) { n = n_; count++; }
 790     ~Foo() { count--; }
 791
 792     int n;
 793
 794     static size_t count;
 795 };
 796
 797 size_t Foo::count = 0;
 798
 799 WX_DECLARE_LIST(Foo, wxListFoos);
 800 WX_DECLARE_HASH(Foo, wxListFoos, wxHashFoos);
 801
 802 #include <wx/listimpl.cpp>
 803
 804 WX_DEFINE_LIST(wxListFoos);
 805
 806 static void TestHash()
 807 {
 808     puts("*** Testing wxHashTable ***\n");
 809
 810     {
 811         wxHashFoos hash;
 812         hash.DeleteContents(TRUE);
 813
 814         printf("Hash created: %u foos in hash, %u foos totally\n",
 815                hash.GetCount(), Foo::count);
 816
 817         static const int hashTestData[] =
 818         {
 819             0, 1, 17, -2, 2, 4, -4, 345, 3, 3, 2, 1,
 820         };
 821
 822         size_t n;
 823         for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
 824         {
 825             hash.Put(hashTestData[n], n, new Foo(n));
 826         }
 827
 828         printf("Hash filled: %u foos in hash, %u foos totally\n",
 829                hash.GetCount(), Foo::count);
 830
 831         puts("Hash access test:");
 832         for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
 833         {
 834             printf("\tGetting element with key %d, value %d: ",
 835                    hashTestData[n], n);
 836             Foo *foo = hash.Get(hashTestData[n], n);
 837             if ( !foo )
 838             {
 839                 printf("ERROR, not found.\n");
 840             }
 841             else
 842             {
 843                 printf("%d (%s)\n", foo->n,
 844                        (size_t)foo->n == n ? "ok" : "ERROR");
 845             }
 846         }
 847
 848         printf("\nTrying to get an element not in hash: ");
 849
 850         if ( hash.Get(1234) || hash.Get(1, 0) )
 851         {
 852             puts("ERROR: found!");
 853         }
 854         else
 855         {
 856             puts("ok (not found)");
 857         }
 858     }
 859
 860     printf("Hash destroyed: %u foos left\n", Foo::count);
 861 }
 862
 863 #endif // TEST_HASH
 864
 865 // ----------------------------------------------------------------------------
 866 // wxList
 867 // ----------------------------------------------------------------------------
 868
 869 #ifdef TEST_LIST
 870
 871 #include <wx/list.h>
 872
 873 WX_DECLARE_LIST(Bar, wxListBars);
 874 #include <wx/listimpl.cpp>
 875 WX_DEFINE_LIST(wxListBars);
 876
 877 static void TestListCtor()
 878 {
 879     puts("*** Testing wxList construction ***\n");
 880
 881     {
 882         wxListBars list1;
 883         list1.Append(new Bar(_T("first")));
 884         list1.Append(new Bar(_T("second")));
 885
 886         printf("After 1st list creation: %u objects in the list, %u objects total.\n",
 887                list1.GetCount(), Bar::GetNumber());
 888
 889         wxListBars list2;
 890         list2 = list1;
 891
 892         printf("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n",
 893                list1.GetCount(), list2.GetCount(), Bar::GetNumber());
 894
 895         list1.DeleteContents(TRUE);
 896     }
 897
 898     printf("After list destruction: %u objects left.\n", Bar::GetNumber());
 899 }
 900
 901 #endif // TEST_LIST
 902
 903 // ----------------------------------------------------------------------------
 904 // wxLocale
 905 // ----------------------------------------------------------------------------
 906
 907 #ifdef TEST_LOCALE
 908
 909 #include "wx/intl.h"
 910 #include "wx/utils.h"   // for wxSetEnv
 911
 912 static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
 913
 914 // find the name of the language from its value
 915 static const char *GetLangName(int lang)
 916 {
 917     static const char *languageNames[] =
 918     {
 919         "DEFAULT",
 920         "UNKNOWN",
 921         "ABKHAZIAN",
 922         "AFAR",
 923         "AFRIKAANS",
 924         "ALBANIAN",
 925         "AMHARIC",
 926         "ARABIC",
 927         "ARABIC_ALGERIA",
 928         "ARABIC_BAHRAIN",
 929         "ARABIC_EGYPT",
 930         "ARABIC_IRAQ",
 931         "ARABIC_JORDAN",
 932         "ARABIC_KUWAIT",
 933         "ARABIC_LEBANON",
 934         "ARABIC_LIBYA",
 935         "ARABIC_MOROCCO",
 936         "ARABIC_OMAN",
 937         "ARABIC_QATAR",
 938         "ARABIC_SAUDI_ARABIA",
 939         "ARABIC_SUDAN",
 940         "ARABIC_SYRIA",
 941         "ARABIC_TUNISIA",
 942         "ARABIC_UAE",
 943         "ARABIC_YEMEN",
 944         "ARMENIAN",
 945         "ASSAMESE",
 946         "AYMARA",
 947         "AZERI",
 948         "AZERI_CYRILLIC",
 949         "AZERI_LATIN",
 950         "BASHKIR",
 951         "BASQUE",
 952         "BELARUSIAN",
 953         "BENGALI",
 954         "BHUTANI",
 955         "BIHARI",
 956         "BISLAMA",
 957         "BRETON",
 958         "BULGARIAN",
 959         "BURMESE",
 960         "CAMBODIAN",
 961         "CATALAN",
 962         "CHINESE",
 963         "CHINESE_SIMPLIFIED",
 964         "CHINESE_TRADITIONAL",
 965         "CHINESE_HONGKONG",
 966         "CHINESE_MACAU",
 967         "CHINESE_SINGAPORE",
 968         "CHINESE_TAIWAN",
 969         "CORSICAN",
 970         "CROATIAN",
 971         "CZECH",
 972         "DANISH",
 973         "DUTCH",
 974         "DUTCH_BELGIAN",
 975         "ENGLISH",
 976         "ENGLISH_UK",
 977         "ENGLISH_US",
 978         "ENGLISH_AUSTRALIA",
 979         "ENGLISH_BELIZE",
 980         "ENGLISH_BOTSWANA",
 981         "ENGLISH_CANADA",
 982         "ENGLISH_CARIBBEAN",
 983         "ENGLISH_DENMARK",
 984         "ENGLISH_EIRE",
 985         "ENGLISH_JAMAICA",
 986         "ENGLISH_NEW_ZEALAND",
 987         "ENGLISH_PHILIPPINES",
 988         "ENGLISH_SOUTH_AFRICA",
 989         "ENGLISH_TRINIDAD",
 990         "ENGLISH_ZIMBABWE",
 991         "ESPERANTO",
 992         "ESTONIAN",
 993         "FAEROESE",
 994         "FARSI",
 995         "FIJI",
 996         "FINNISH",
 997         "FRENCH",
 998         "FRENCH_BELGIAN",
 999         "FRENCH_CANADIAN",
1000         "FRENCH_LUXEMBOURG",
1001         "FRENCH_MONACO",
1002         "FRENCH_SWISS",
1003         "FRISIAN",
1004         "GALICIAN",
1005         "GEORGIAN",
1006         "GERMAN",
1007         "GERMAN_AUSTRIAN",
1008         "GERMAN_BELGIUM",
1009         "GERMAN_LIECHTENSTEIN",
1010         "GERMAN_LUXEMBOURG",
1011         "GERMAN_SWISS",
1012         "GREEK",
1013         "GREENLANDIC",
1014         "GUARANI",
1015         "GUJARATI",
1016         "HAUSA",
1017         "HEBREW",
1018         "HINDI",
1019         "HUNGARIAN",
1020         "ICELANDIC",
1021         "INDONESIAN",
1022         "INTERLINGUA",
1023         "INTERLINGUE",
1024         "INUKTITUT",
1025         "INUPIAK",
1026         "IRISH",
1027         "ITALIAN",
1028         "ITALIAN_SWISS",
1029         "JAPANESE",
1030         "JAVANESE",
1031         "KANNADA",
1032         "KASHMIRI",
1033         "KASHMIRI_INDIA",
1034         "KAZAKH",
1035         "KERNEWEK",
1036         "KINYARWANDA",
1037         "KIRGHIZ",
1038         "KIRUNDI",
1039         "KONKANI",
1040         "KOREAN",
1041         "KURDISH",
1042         "LAOTHIAN",
1043         "LATIN",
1044         "LATVIAN",
1045         "LINGALA",
1046         "LITHUANIAN",
1047         "MACEDONIAN",
1048         "MALAGASY",
1049         "MALAY",
1050         "MALAYALAM",
1051         "MALAY_BRUNEI_DARUSSALAM",
1052         "MALAY_MALAYSIA",
1053         "MALTESE",
1054         "MANIPURI",
1055         "MAORI",
1056         "MARATHI",
1057         "MOLDAVIAN",
1058         "MONGOLIAN",
1059         "NAURU",
1060         "NEPALI",
1061         "NEPALI_INDIA",
1062         "NORWEGIAN_BOKMAL",
1063         "NORWEGIAN_NYNORSK",
1064         "OCCITAN",
1065         "ORIYA",
1066         "OROMO",
1067         "PASHTO",
1068         "POLISH",
1069         "PORTUGUESE",
1070         "PORTUGUESE_BRAZILIAN",
1071         "PUNJABI",
1072         "QUECHUA",
1073         "RHAETO_ROMANCE",
1074         "ROMANIAN",
1075         "RUSSIAN",
1076         "RUSSIAN_UKRAINE",
1077         "SAMOAN",
1078         "SANGHO",
1079         "SANSKRIT",
1080         "SCOTS_GAELIC",
1081         "SERBIAN",
1082         "SERBIAN_CYRILLIC",
1083         "SERBIAN_LATIN",
1084         "SERBO_CROATIAN",
1085         "SESOTHO",
1086         "SETSWANA",
1087         "SHONA",
1088         "SINDHI",
1089         "SINHALESE",
1090         "SISWATI",
1091         "SLOVAK",
1092         "SLOVENIAN",
1093         "SOMALI",
1094         "SPANISH",
1095         "SPANISH_ARGENTINA",
1096         "SPANISH_BOLIVIA",
1097         "SPANISH_CHILE",
1098         "SPANISH_COLOMBIA",
1099         "SPANISH_COSTA_RICA",
1100         "SPANISH_DOMINICAN_REPUBLIC",
1101         "SPANISH_ECUADOR",
1102         "SPANISH_EL_SALVADOR",
1103         "SPANISH_GUATEMALA",
1104         "SPANISH_HONDURAS",
1105         "SPANISH_MEXICAN",
1106         "SPANISH_MODERN",
1107         "SPANISH_NICARAGUA",
1108         "SPANISH_PANAMA",
1109         "SPANISH_PARAGUAY",
1110         "SPANISH_PERU",
1111         "SPANISH_PUERTO_RICO",
1112         "SPANISH_URUGUAY",
1113         "SPANISH_US",
1114         "SPANISH_VENEZUELA",
1115         "SUNDANESE",
1116         "SWAHILI",
1117         "SWEDISH",
1118         "SWEDISH_FINLAND",
1119         "TAGALOG",
1120         "TAJIK",
1121         "TAMIL",
1122         "TATAR",
1123         "TELUGU",
1124         "THAI",
1125         "TIBETAN",
1126         "TIGRINYA",
1127         "TONGA",
1128         "TSONGA",
1129         "TURKISH",
1130         "TURKMEN",
1131         "TWI",
1132         "UIGHUR",
1133         "UKRAINIAN",
1134         "URDU",
1135         "URDU_INDIA",
1136         "URDU_PAKISTAN",
1137         "UZBEK",
1138         "UZBEK_CYRILLIC",
1139         "UZBEK_LATIN",
1140         "VIETNAMESE",
1141         "VOLAPUK",
1142         "WELSH",
1143         "WOLOF",
1144         "XHOSA",
1145         "YIDDISH",
1146         "YORUBA",
1147         "ZHUANG",
1148         "ZULU",
1149     };
1150
1151     if ( (size_t)lang < WXSIZEOF(languageNames) )
1152         return languageNames[lang];
1153     else
1154         return "INVALID";
1155 }
1156
1157 static void TestDefaultLang()
1158 {
1159     puts("*** Testing wxLocale::GetSystemLanguage ***");
1160
1161     static const wxChar *langStrings[] =
1162     {
1163         NULL,               // system default
1164         _T("C"),
1165         _T("fr"),
1166         _T("fr_FR"),
1167         _T("en"),
1168         _T("en_GB"),
1169         _T("en_US"),
1170         _T("de_DE.iso88591"),
1171         _T("german"),
1172         _T("?"),            // invalid lang spec
1173         _T("klingonese"),   // I bet on some systems it does exist...
1174     };
1175
1176     for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1177     {
1178         const char *langStr = langStrings[n];
1179         if ( langStr )
1180             wxSetEnv(_T("LC_ALL"), langStr);
1181
1182         int lang = gs_localeDefault.GetSystemLanguage();
1183         printf("Locale for '%s' is %s.\n",
1184                langStr ? langStr : "system default", GetLangName(lang));
1185     }
1186 }
1187
1188 #endif // TEST_LOCALE
1189
1190 // ----------------------------------------------------------------------------
1191 // MIME types
1192 // ----------------------------------------------------------------------------
1193
1194 #ifdef TEST_MIME
1195
1196 #include <wx/mimetype.h>
1197
1198 static void TestMimeEnum()
1199 {
1200     wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1201
1202     wxArrayString mimetypes;
1203
1204     size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1205
1206     printf("*** All %u known filetypes: ***\n", count);
1207
1208     wxArrayString exts;
1209     wxString desc;
1210
1211     for ( size_t n = 0; n < count; n++ )
1212     {
1213         wxFileType *filetype =
1214             wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1215         if ( !filetype )
1216         {
1217             printf("nothing known about the filetype '%s'!\n",
1218                    mimetypes[n].c_str());
1219             continue;
1220         }
1221
1222         filetype->GetDescription(&desc);
1223         filetype->GetExtensions(exts);
1224
1225         filetype->GetIcon(NULL);
1226
1227         wxString extsAll;
1228         for ( size_t e = 0; e < exts.GetCount(); e++ )
1229         {
1230             if ( e > 0 )
1231                 extsAll << _T(", ");
1232             extsAll += exts[e];
1233         }
1234
1235         printf("\t%s: %s (%s)\n",
1236                mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1237     }
1238
1239     puts("");
1240 }
1241
1242 static void TestMimeOverride()
1243 {
1244     wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1245
1246     static const wxChar *mailcap = _T("/tmp/mailcap");
1247     static const wxChar *mimetypes = _T("/tmp/mime.types");
1248
1249     if ( wxFile::Exists(mailcap) )
1250         wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1251                  mailcap,
1252                  wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
1253     else
1254         wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1255                  mailcap);
1256
1257     if ( wxFile::Exists(mimetypes) )
1258         wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1259                  mimetypes,
1260                  wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
1261     else
1262         wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1263                  mimetypes);
1264
1265     puts("");
1266 }
1267
1268 static void TestMimeFilename()
1269 {
1270     wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1271
1272     static const wxChar *filenames[] =
1273     {
1274         _T("readme.txt"),
1275         _T("document.pdf"),
1276         _T("image.gif"),
1277     };
1278
1279     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1280     {
1281         const wxString fname = filenames[n];
1282         wxString ext = fname.AfterLast(_T('.'));
1283         wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1284         if ( !ft )
1285         {
1286             wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1287         }
1288         else
1289         {
1290             wxString desc;
1291             if ( !ft->GetDescription(&desc) )
1292                 desc = _T("<no description>");
1293
1294             wxString cmd;
1295             if ( !ft->GetOpenCommand(&cmd,
1296                                      wxFileType::MessageParameters(fname, _T(""))) )
1297                 cmd = _T("<no command available>");
1298
1299             wxPrintf(_T("To open %s (%s) do '%s'.\n"),
1300                      fname.c_str(), desc.c_str(), cmd.c_str());
1301
1302             delete ft;
1303         }
1304     }
1305
1306     puts("");
1307 }
1308
1309 static void TestMimeAssociate()
1310 {
1311     wxPuts(_T("*** Testing creation of filetype association ***\n"));
1312
1313     wxFileTypeInfo ftInfo(
1314                             _T("application/x-xyz"),
1315                             _T("xyzview '%s'"), // open cmd
1316                             _T(""),             // print cmd
1317                             _T("XYZ File")  // description
1318                             _T(".xyz"),     // extensions
1319                             NULL            // end of extensions
1320                          );
1321     ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1322
1323     wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1324     if ( !ft )
1325     {
1326         wxPuts(_T("ERROR: failed to create association!"));
1327     }
1328     else
1329     {
1330         // TODO: read it back
1331         delete ft;
1332     }
1333
1334     puts("");
1335 }
1336
1337 #endif // TEST_MIME
1338
1339 // ----------------------------------------------------------------------------
1340 // misc information functions
1341 // ----------------------------------------------------------------------------
1342
1343 #ifdef TEST_INFO_FUNCTIONS
1344
1345 #include <wx/utils.h>
1346
1347 static void TestOsInfo()
1348 {
1349     puts("*** Testing OS info functions ***\n");
1350
1351     int major, minor;
1352     wxGetOsVersion(&major, &minor);
1353     printf("Running under: %s, version %d.%d\n",
1354             wxGetOsDescription().c_str(), major, minor);
1355
1356     printf("%ld free bytes of memory left.\n", wxGetFreeMemory());
1357
1358     printf("Host name is %s (%s).\n",
1359            wxGetHostName().c_str(), wxGetFullHostName().c_str());
1360
1361     puts("");
1362 }
1363
1364 static void TestUserInfo()
1365 {
1366     puts("*** Testing user info functions ***\n");
1367
1368     printf("User id is:\t%s\n", wxGetUserId().c_str());
1369     printf("User name is:\t%s\n", wxGetUserName().c_str());
1370     printf("Home dir is:\t%s\n", wxGetHomeDir().c_str());
1371     printf("Email address:\t%s\n", wxGetEmailAddress().c_str());
1372
1373     puts("");
1374 }
1375
1376 #endif // TEST_INFO_FUNCTIONS
1377
1378 // ----------------------------------------------------------------------------
1379 // long long
1380 // ----------------------------------------------------------------------------
1381
1382 #ifdef TEST_LONGLONG
1383
1384 #include <wx/longlong.h>
1385 #include <wx/timer.h>
1386
1387 // make a 64 bit number from 4 16 bit ones
1388 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
1389
1390 // get a random 64 bit number
1391 #define RAND_LL()   MAKE_LL(rand(), rand(), rand(), rand())
1392
1393 #if wxUSE_LONGLONG_WX
1394 inline bool operator==(const wxLongLongWx& a, const wxLongLongNative& b)
1395     { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
1396 inline bool operator==(const wxLongLongNative& a, const wxLongLongWx& b)
1397     { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
1398 #endif // wxUSE_LONGLONG_WX
1399
1400 static void TestSpeed()
1401 {
1402     static const long max = 100000000;
1403     long n;
1404
1405     {
1406         wxStopWatch sw;
1407
1408         long l = 0;
1409         for ( n = 0; n < max; n++ )
1410         {
1411             l += n;
1412         }
1413
1414         printf("Summing longs took %ld milliseconds.\n", sw.Time());
1415     }
1416
1417 #if wxUSE_LONGLONG_NATIVE
1418     {
1419         wxStopWatch sw;
1420
1421         wxLongLong_t l = 0;
1422         for ( n = 0; n < max; n++ )
1423         {
1424             l += n;
1425         }
1426
1427         printf("Summing wxLongLong_t took %ld milliseconds.\n", sw.Time());
1428     }
1429 #endif // wxUSE_LONGLONG_NATIVE
1430
1431     {
1432         wxStopWatch sw;
1433
1434         wxLongLong l;
1435         for ( n = 0; n < max; n++ )
1436         {
1437             l += n;
1438         }
1439
1440         printf("Summing wxLongLongs took %ld milliseconds.\n", sw.Time());
1441     }
1442 }
1443
1444 static void TestLongLongConversion()
1445 {
1446     puts("*** Testing wxLongLong conversions ***\n");
1447
1448     wxLongLong a;
1449     size_t nTested = 0;
1450     for ( size_t n = 0; n < 100000; n++ )
1451     {
1452         a = RAND_LL();
1453
1454 #if wxUSE_LONGLONG_NATIVE
1455         wxLongLongNative b(a.GetHi(), a.GetLo());
1456
1457         wxASSERT_MSG( a == b, "conversions failure" );
1458 #else
1459         puts("Can't do it without native long long type, test skipped.");
1460
1461         return;
1462 #endif // wxUSE_LONGLONG_NATIVE
1463
1464         if ( !(nTested % 1000) )
1465         {
1466             putchar('.');
1467             fflush(stdout);
1468         }
1469
1470         nTested++;
1471     }
1472
1473     puts(" done!");
1474 }
1475
1476 static void TestMultiplication()
1477 {
1478     puts("*** Testing wxLongLong multiplication ***\n");
1479
1480     wxLongLong a, b;
1481     size_t nTested = 0;
1482     for ( size_t n = 0; n < 100000; n++ )
1483     {
1484         a = RAND_LL();
1485         b = RAND_LL();
1486
1487 #if wxUSE_LONGLONG_NATIVE
1488         wxLongLongNative aa(a.GetHi(), a.GetLo());
1489         wxLongLongNative bb(b.GetHi(), b.GetLo());
1490
1491         wxASSERT_MSG( a*b == aa*bb, "multiplication failure" );
1492 #else // !wxUSE_LONGLONG_NATIVE
1493         puts("Can't do it without native long long type, test skipped.");
1494
1495         return;
1496 #endif // wxUSE_LONGLONG_NATIVE
1497
1498         if ( !(nTested % 1000) )
1499         {
1500             putchar('.');
1501             fflush(stdout);
1502         }
1503
1504         nTested++;
1505     }
1506
1507     puts(" done!");
1508 }
1509
1510 static void TestDivision()
1511 {
1512     puts("*** Testing wxLongLong division ***\n");
1513
1514     wxLongLong q, r;
1515     size_t nTested = 0;
1516     for ( size_t n = 0; n < 100000; n++ )
1517     {
1518         // get a random wxLongLong (shifting by 12 the MSB ensures that the
1519         // multiplication will not overflow)
1520         wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
1521
1522         // get a random long (not wxLongLong for now) to divide it with
1523         long l = rand();
1524         q = ll / l;
1525         r = ll % l;
1526
1527 #if wxUSE_LONGLONG_NATIVE
1528         wxLongLongNative m(ll.GetHi(), ll.GetLo());
1529
1530         wxLongLongNative p = m / l, s = m % l;
1531         wxASSERT_MSG( q == p && r == s, "division failure" );
1532 #else // !wxUSE_LONGLONG_NATIVE
1533         // verify the result
1534         wxASSERT_MSG( ll == q*l + r, "division failure" );
1535 #endif // wxUSE_LONGLONG_NATIVE
1536
1537         if ( !(nTested % 1000) )
1538         {
1539             putchar('.');
1540             fflush(stdout);
1541         }
1542
1543         nTested++;
1544     }
1545
1546     puts(" done!");
1547 }
1548
1549 static void TestAddition()
1550 {
1551     puts("*** Testing wxLongLong addition ***\n");
1552
1553     wxLongLong a, b, c;
1554     size_t nTested = 0;
1555     for ( size_t n = 0; n < 100000; n++ )
1556     {
1557         a = RAND_LL();
1558         b = RAND_LL();
1559         c = a + b;
1560
1561 #if wxUSE_LONGLONG_NATIVE
1562         wxASSERT_MSG( c == wxLongLongNative(a.GetHi(), a.GetLo()) +
1563                            wxLongLongNative(b.GetHi(), b.GetLo()),
1564                       "addition failure" );
1565 #else // !wxUSE_LONGLONG_NATIVE
1566         wxASSERT_MSG( c - b == a, "addition failure" );
1567 #endif // wxUSE_LONGLONG_NATIVE
1568
1569         if ( !(nTested % 1000) )
1570         {
1571             putchar('.');
1572             fflush(stdout);
1573         }
1574
1575         nTested++;
1576     }
1577
1578     puts(" done!");
1579 }
1580
1581 static void TestBitOperations()
1582 {
1583     puts("*** Testing wxLongLong bit operation ***\n");
1584
1585     wxLongLong ll;
1586     size_t nTested = 0;
1587     for ( size_t n = 0; n < 100000; n++ )
1588     {
1589         ll = RAND_LL();
1590
1591 #if wxUSE_LONGLONG_NATIVE
1592         for ( size_t n = 0; n < 33; n++ )
1593         {
1594         }
1595 #else // !wxUSE_LONGLONG_NATIVE
1596         puts("Can't do it without native long long type, test skipped.");
1597
1598         return;
1599 #endif // wxUSE_LONGLONG_NATIVE
1600
1601         if ( !(nTested % 1000) )
1602         {
1603             putchar('.');
1604             fflush(stdout);
1605         }
1606
1607         nTested++;
1608     }
1609
1610     puts(" done!");
1611 }
1612
1613 static void TestLongLongComparison()
1614 {
1615     puts("*** Testing wxLongLong comparison ***\n");
1616
1617     static const long testLongs[] =
1618     {
1619         0,
1620         1,
1621         -1,
1622         LONG_MAX,
1623         LONG_MIN,
1624         0x1234,
1625         -0x1234
1626     };
1627
1628     static const long ls[2] =
1629     {
1630         0x1234,
1631        -0x1234,
1632     };
1633
1634     wxLongLongWx lls[2];
1635     lls[0] = ls[0];
1636     lls[1] = ls[1];
1637
1638     for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
1639     {
1640         bool res;
1641
1642         for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
1643         {
1644             res = lls[m] > testLongs[n];
1645             printf("0x%lx > 0x%lx is %s (%s)\n",
1646                    ls[m], testLongs[n], res ? "true" : "false",
1647                    res == (ls[m] > testLongs[n]) ? "ok" : "ERROR");
1648
1649             res = lls[m] < testLongs[n];
1650             printf("0x%lx < 0x%lx is %s (%s)\n",
1651                    ls[m], testLongs[n], res ? "true" : "false",
1652                    res == (ls[m] < testLongs[n]) ? "ok" : "ERROR");
1653
1654             res = lls[m] == testLongs[n];
1655             printf("0x%lx == 0x%lx is %s (%s)\n",
1656                    ls[m], testLongs[n], res ? "true" : "false",
1657                    res == (ls[m] == testLongs[n]) ? "ok" : "ERROR");
1658         }
1659     }
1660 }
1661
1662 #undef MAKE_LL
1663 #undef RAND_LL
1664
1665 #endif // TEST_LONGLONG
1666
1667 // ----------------------------------------------------------------------------
1668 // path list
1669 // ----------------------------------------------------------------------------
1670
1671 #ifdef TEST_PATHLIST
1672
1673 static void TestPathList()
1674 {
1675     puts("*** Testing wxPathList ***\n");
1676
1677     wxPathList pathlist;
1678     pathlist.AddEnvList("PATH");
1679     wxString path = pathlist.FindValidPath("ls");
1680     if ( path.empty() )
1681     {
1682         printf("ERROR: command not found in the path.\n");
1683     }
1684     else
1685     {
1686         printf("Command found in the path as '%s'.\n", path.c_str());
1687     }
1688 }
1689
1690 #endif // TEST_PATHLIST
1691
1692 // ----------------------------------------------------------------------------
1693 // registry and related stuff
1694 // ----------------------------------------------------------------------------
1695
1696 // this is for MSW only
1697 #ifndef __WXMSW__
1698     #undef TEST_REGCONF
1699     #undef TEST_REGISTRY
1700 #endif
1701
1702 #ifdef TEST_REGCONF
1703
1704 #include <wx/confbase.h>
1705 #include <wx/msw/regconf.h>
1706
1707 static void TestRegConfWrite()
1708 {
1709     wxRegConfig regconf(_T("console"), _T("wxwindows"));
1710     regconf.Write(_T("Hello"), wxString(_T("world")));
1711 }
1712
1713 #endif // TEST_REGCONF
1714
1715 #ifdef TEST_REGISTRY
1716
1717 #include <wx/msw/registry.h>
1718
1719 // I chose this one because I liked its name, but it probably only exists under
1720 // NT
1721 static const wxChar *TESTKEY =
1722     _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
1723
1724 static void TestRegistryRead()
1725 {
1726     puts("*** testing registry reading ***");
1727
1728     wxRegKey key(TESTKEY);
1729     printf("The test key name is '%s'.\n", key.GetName().c_str());
1730     if ( !key.Open() )
1731     {
1732         puts("ERROR: test key can't be opened, aborting test.");
1733
1734         return;
1735     }
1736
1737     size_t nSubKeys, nValues;
1738     if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
1739     {
1740         printf("It has %u subkeys and %u values.\n", nSubKeys, nValues);
1741     }
1742
1743     printf("Enumerating values:\n");
1744
1745     long dummy;
1746     wxString value;
1747     bool cont = key.GetFirstValue(value, dummy);
1748     while ( cont )
1749     {
1750         printf("Value '%s': type ", value.c_str());
1751         switch ( key.GetValueType(value) )
1752         {
1753             case wxRegKey::Type_None:   printf("ERROR (none)"); break;
1754             case wxRegKey::Type_String: printf("SZ"); break;
1755             case wxRegKey::Type_Expand_String: printf("EXPAND_SZ"); break;
1756             case wxRegKey::Type_Binary: printf("BINARY"); break;
1757             case wxRegKey::Type_Dword: printf("DWORD"); break;
1758             case wxRegKey::Type_Multi_String: printf("MULTI_SZ"); break;
1759             default: printf("other (unknown)"); break;
1760         }
1761
1762         printf(", value = ");
1763         if ( key.IsNumericValue(value) )
1764         {
1765             long val;
1766             key.QueryValue(value, &val);
1767             printf("%ld", val);
1768         }
1769         else // string
1770         {
1771             wxString val;
1772             key.QueryValue(value, val);
1773             printf("'%s'", val.c_str());
1774
1775             key.QueryRawValue(value, val);
1776             printf(" (raw value '%s')", val.c_str());
1777         }
1778
1779         putchar('\n');
1780
1781         cont = key.GetNextValue(value, dummy);
1782     }
1783 }
1784
1785 static void TestRegistryAssociation()
1786 {
1787     /*
1788        The second call to deleteself genertaes an error message, with a
1789        messagebox saying .flo is crucial to system operation, while the .ddf
1790        call also fails, but with no error message
1791     */
1792
1793     wxRegKey key;
1794
1795     key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
1796     key.Create();
1797     key = "ddxf_auto_file" ;
1798     key.SetName("HKEY_CLASSES_ROOT\\.flo" );
1799     key.Create();
1800     key = "ddxf_auto_file" ;
1801     key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
1802     key.Create();
1803     key = "program,0" ;
1804     key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
1805     key.Create();
1806     key = "program \"%1\"" ;
1807
1808     key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
1809     key.DeleteSelf();
1810     key.SetName("HKEY_CLASSES_ROOT\\.flo" );
1811     key.DeleteSelf();
1812     key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
1813     key.DeleteSelf();
1814     key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
1815     key.DeleteSelf();
1816 }
1817
1818 #endif // TEST_REGISTRY
1819
1820 // ----------------------------------------------------------------------------
1821 // sockets
1822 // ----------------------------------------------------------------------------
1823
1824 #ifdef TEST_SOCKETS
1825
1826 #include <wx/socket.h>
1827 #include <wx/protocol/protocol.h>
1828 #include <wx/protocol/http.h>
1829
1830 static void TestSocketServer()
1831 {
1832     puts("*** Testing wxSocketServer ***\n");
1833
1834     static const int PORT = 3000;
1835
1836     wxIPV4address addr;
1837     addr.Service(PORT);
1838
1839     wxSocketServer *server = new wxSocketServer(addr);
1840     if ( !server->Ok() )
1841     {
1842         puts("ERROR: failed to bind");
1843
1844         return;
1845     }
1846
1847     for ( ;; )
1848     {
1849         printf("Server: waiting for connection on port %d...\n", PORT);
1850
1851         wxSocketBase *socket = server->Accept();
1852         if ( !socket )
1853         {
1854             puts("ERROR: wxSocketServer::Accept() failed.");
1855             break;
1856         }
1857
1858         puts("Server: got a client.");
1859
1860         server->SetTimeout(60); // 1 min
1861
1862         while ( socket->IsConnected() )
1863         {
1864             wxString s;
1865             char ch = '\0';
1866             for ( ;; )
1867             {
1868                 if ( socket->Read(&ch, sizeof(ch)).Error() )
1869                 {
1870                     // don't log error if the client just close the connection
1871                     if ( socket->IsConnected() )
1872                     {
1873                         puts("ERROR: in wxSocket::Read.");
1874                     }
1875
1876                     break;
1877                 }
1878
1879                 if ( ch == '\r' )
1880                     continue;
1881
1882                 if ( ch == '\n' )
1883                     break;
1884
1885                 s += ch;
1886             }
1887
1888             if ( ch != '\n' )
1889             {
1890                 break;
1891             }
1892
1893             printf("Server: got '%s'.\n", s.c_str());
1894             if ( s == _T("bye") )
1895             {
1896                 delete socket;
1897
1898                 break;
1899             }
1900
1901             socket->Write(s.MakeUpper().c_str(), s.length());
1902             socket->Write("\r\n", 2);
1903             printf("Server: wrote '%s'.\n", s.c_str());
1904         }
1905
1906         puts("Server: lost a client.");
1907
1908         socket->Destroy();
1909     }
1910
1911     // same as "delete server" but is consistent with GUI programs
1912     server->Destroy();
1913 }
1914
1915 static void TestSocketClient()
1916 {
1917     puts("*** Testing wxSocketClient ***\n");
1918
1919     static const char *hostname = "www.wxwindows.org";
1920
1921     wxIPV4address addr;
1922     addr.Hostname(hostname);
1923     addr.Service(80);
1924
1925     printf("--- Attempting to connect to %s:80...\n", hostname);
1926
1927     wxSocketClient client;
1928     if ( !client.Connect(addr) )
1929     {
1930         printf("ERROR: failed to connect to %s\n", hostname);
1931     }
1932     else
1933     {
1934         printf("--- Connected to %s:%u...\n",
1935                addr.Hostname().c_str(), addr.Service());
1936
1937         char buf[8192];
1938
1939         // could use simply "GET" here I suppose
1940         wxString cmdGet =
1941             wxString::Format("GET http://%s/\r\n", hostname);
1942         client.Write(cmdGet, cmdGet.length());
1943         printf("--- Sent command '%s' to the server\n",
1944                MakePrintable(cmdGet).c_str());
1945         client.Read(buf, WXSIZEOF(buf));
1946         printf("--- Server replied:\n%s", buf);
1947     }
1948 }
1949
1950 #endif // TEST_SOCKETS
1951
1952 // ----------------------------------------------------------------------------
1953 // FTP
1954 // ----------------------------------------------------------------------------
1955
1956 #ifdef TEST_FTP
1957
1958 #include <wx/protocol/ftp.h>
1959
1960 static wxFTP ftp;
1961
1962 #define FTP_ANONYMOUS
1963
1964 #ifdef FTP_ANONYMOUS
1965     static const char *directory = "/pub";
1966     static const char *filename = "welcome.msg";
1967 #else
1968     static const char *directory = "/etc";
1969     static const char *filename = "issue";
1970 #endif
1971
1972 static bool TestFtpConnect()
1973 {
1974     puts("*** Testing FTP connect ***");
1975
1976 #ifdef FTP_ANONYMOUS
1977     static const char *hostname = "ftp.wxwindows.org";
1978
1979     printf("--- Attempting to connect to %s:21 anonymously...\n", hostname);
1980 #else // !FTP_ANONYMOUS
1981     static const char *hostname = "localhost";
1982
1983     char user[256];
1984     fgets(user, WXSIZEOF(user), stdin);
1985     user[strlen(user) - 1] = '\0'; // chop off '\n'
1986     ftp.SetUser(user);
1987
1988     char password[256];
1989     printf("Password for %s: ", password);
1990     fgets(password, WXSIZEOF(password), stdin);
1991     password[strlen(password) - 1] = '\0'; // chop off '\n'
1992     ftp.SetPassword(password);
1993
1994     printf("--- Attempting to connect to %s:21 as %s...\n", hostname, user);
1995 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
1996
1997     if ( !ftp.Connect(hostname) )
1998     {
1999         printf("ERROR: failed to connect to %s\n", hostname);
2000
2001         return FALSE;
2002     }
2003     else
2004     {
2005         printf("--- Connected to %s, current directory is '%s'\n",
2006                hostname, ftp.Pwd().c_str());
2007     }
2008
2009     return TRUE;
2010 }
2011
2012 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2013 static void TestFtpWuFtpd()
2014 {
2015     wxFTP ftp;
2016     static const char *hostname = "ftp.eudora.com";
2017     if ( !ftp.Connect(hostname) )
2018     {
2019         printf("ERROR: failed to connect to %s\n", hostname);
2020     }
2021     else
2022     {
2023         static const char *filename = "eudora/pubs/draft-gellens-submit-09.txt";
2024         wxInputStream *in = ftp.GetInputStream(filename);
2025         if ( !in )
2026         {
2027             printf("ERROR: couldn't get input stream for %s\n", filename);
2028         }
2029         else
2030         {
2031             size_t size = in->StreamSize();
2032             printf("Reading file %s (%u bytes)...", filename, size);
2033
2034             char *data = new char[size];
2035             if ( !in->Read(data, size) )
2036             {
2037                 puts("ERROR: read error");
2038             }
2039             else
2040             {
2041                 printf("Successfully retrieved the file.\n");
2042             }
2043
2044             delete [] data;
2045             delete in;
2046         }
2047     }
2048 }
2049
2050 static void TestFtpList()
2051 {
2052     puts("*** Testing wxFTP file listing ***\n");
2053
2054     // test CWD
2055     if ( !ftp.ChDir(directory) )
2056     {
2057         printf("ERROR: failed to cd to %s\n", directory);
2058     }
2059
2060     printf("Current directory is '%s'\n", ftp.Pwd().c_str());
2061
2062     // test NLIST and LIST
2063     wxArrayString files;
2064     if ( !ftp.GetFilesList(files) )
2065     {
2066         puts("ERROR: failed to get NLIST of files");
2067     }
2068     else
2069     {
2070         printf("Brief list of files under '%s':\n", ftp.Pwd().c_str());
2071         size_t count = files.GetCount();
2072         for ( size_t n = 0; n < count; n++ )
2073         {
2074             printf("\t%s\n", files[n].c_str());
2075         }
2076         puts("End of the file list");
2077     }
2078
2079     if ( !ftp.GetDirList(files) )
2080     {
2081         puts("ERROR: failed to get LIST of files");
2082     }
2083     else
2084     {
2085         printf("Detailed list of files under '%s':\n", ftp.Pwd().c_str());
2086         size_t count = files.GetCount();
2087         for ( size_t n = 0; n < count; n++ )
2088         {
2089             printf("\t%s\n", files[n].c_str());
2090         }
2091         puts("End of the file list");
2092     }
2093
2094     if ( !ftp.ChDir(_T("..")) )
2095     {
2096         puts("ERROR: failed to cd to ..");
2097     }
2098
2099     printf("Current directory is '%s'\n", ftp.Pwd().c_str());
2100 }
2101
2102 static void TestFtpDownload()
2103 {
2104     puts("*** Testing wxFTP download ***\n");
2105
2106     // test RETR
2107     wxInputStream *in = ftp.GetInputStream(filename);
2108     if ( !in )
2109     {
2110         printf("ERROR: couldn't get input stream for %s\n", filename);
2111     }
2112     else
2113     {
2114         size_t size = in->StreamSize();
2115         printf("Reading file %s (%u bytes)...", filename, size);
2116         fflush(stdout);
2117
2118         char *data = new char[size];
2119         if ( !in->Read(data, size) )
2120         {
2121             puts("ERROR: read error");
2122         }
2123         else
2124         {
2125             printf("\nContents of %s:\n%s\n", filename, data);
2126         }
2127
2128         delete [] data;
2129         delete in;
2130     }
2131 }
2132
2133 static void TestFtpFileSize()
2134 {
2135     puts("*** Testing FTP SIZE command ***");
2136
2137     if ( !ftp.ChDir(directory) )
2138     {
2139         printf("ERROR: failed to cd to %s\n", directory);
2140     }
2141
2142     printf("Current directory is '%s'\n", ftp.Pwd().c_str());
2143
2144     if ( ftp.FileExists(filename) )
2145     {
2146         int size = ftp.GetFileSize(filename);
2147         if ( size == -1 )
2148             printf("ERROR: couldn't get size of '%s'\n", filename);
2149         else
2150             printf("Size of '%s' is %d bytes.\n", filename, size);
2151     }
2152     else
2153     {
2154         printf("ERROR: '%s' doesn't exist\n", filename);
2155     }
2156 }
2157
2158 static void TestFtpMisc()
2159 {
2160     puts("*** Testing miscellaneous wxFTP functions ***");
2161
2162     if ( ftp.SendCommand("STAT") != '2' )
2163     {
2164         puts("ERROR: STAT failed");
2165     }
2166     else
2167     {
2168         printf("STAT returned:\n\n%s\n", ftp.GetLastResult().c_str());
2169     }
2170
2171     if ( ftp.SendCommand("HELP SITE") != '2' )
2172     {
2173         puts("ERROR: HELP SITE failed");
2174     }
2175     else
2176     {
2177         printf("The list of site-specific commands:\n\n%s\n",
2178                ftp.GetLastResult().c_str());
2179     }
2180 }
2181
2182 static void TestFtpInteractive()
2183 {
2184     puts("\n*** Interactive wxFTP test ***");
2185
2186     char buf[128];
2187
2188     for ( ;; )
2189     {
2190         printf("Enter FTP command: ");
2191         if ( !fgets(buf, WXSIZEOF(buf), stdin) )
2192             break;
2193
2194         // kill the last '\n'
2195         buf[strlen(buf) - 1] = 0;
2196
2197         // special handling of LIST and NLST as they require data connection
2198         wxString start(buf, 4);
2199         start.MakeUpper();
2200         if ( start == "LIST" || start == "NLST" )
2201         {
2202             wxString wildcard;
2203             if ( strlen(buf) > 4 )
2204                 wildcard = buf + 5;
2205
2206             wxArrayString files;
2207             if ( !ftp.GetList(files, wildcard, start == "LIST") )
2208             {
2209                 printf("ERROR: failed to get %s of files\n", start.c_str());
2210             }
2211             else
2212             {
2213                 printf("--- %s of '%s' under '%s':\n",
2214                        start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
2215                 size_t count = files.GetCount();
2216                 for ( size_t n = 0; n < count; n++ )
2217                 {
2218                     printf("\t%s\n", files[n].c_str());
2219                 }
2220                 puts("--- End of the file list");
2221             }
2222         }
2223         else // !list
2224         {
2225             char ch = ftp.SendCommand(buf);
2226             printf("Command %s", ch ? "succeeded" : "failed");
2227             if ( ch )
2228             {
2229                 printf(" (return code %c)", ch);
2230             }
2231
2232             printf(", server reply:\n%s\n\n", ftp.GetLastResult().c_str());
2233         }
2234     }
2235
2236     puts("\n*** done ***");
2237 }
2238
2239 static void TestFtpUpload()
2240 {
2241     puts("*** Testing wxFTP uploading ***\n");
2242
2243     // upload a file
2244     static const char *file1 = "test1";
2245     static const char *file2 = "test2";
2246     wxOutputStream *out = ftp.GetOutputStream(file1);
2247     if ( out )
2248     {
2249         printf("--- Uploading to %s ---\n", file1);
2250         out->Write("First hello", 11);
2251         delete out;
2252     }
2253
2254     // send a command to check the remote file
2255     if ( ftp.SendCommand(wxString("STAT ") + file1) != '2' )
2256     {
2257         printf("ERROR: STAT %s failed\n", file1);
2258     }
2259     else
2260     {
2261         printf("STAT %s returned:\n\n%s\n",
2262                file1, ftp.GetLastResult().c_str());
2263     }
2264
2265     out = ftp.GetOutputStream(file2);
2266     if ( out )
2267     {
2268         printf("--- Uploading to %s ---\n", file1);
2269         out->Write("Second hello", 12);
2270         delete out;
2271     }
2272 }
2273
2274 #endif // TEST_FTP
2275
2276 // ----------------------------------------------------------------------------
2277 // streams
2278 // ----------------------------------------------------------------------------
2279
2280 #ifdef TEST_STREAMS
2281
2282 #include <wx/wfstream.h>
2283 #include <wx/mstream.h>
2284
2285 static void TestFileStream()
2286 {
2287     puts("*** Testing wxFileInputStream ***");
2288
2289     static const wxChar *filename = _T("testdata.fs");
2290     {
2291         wxFileOutputStream fsOut(filename);
2292         fsOut.Write("foo", 3);
2293     }
2294
2295     wxFileInputStream fsIn(filename);
2296     printf("File stream size: %u\n", fsIn.GetSize());
2297     while ( !fsIn.Eof() )
2298     {
2299         putchar(fsIn.GetC());
2300     }
2301
2302     if ( !wxRemoveFile(filename) )
2303     {
2304         printf("ERROR: failed to remove the file '%s'.\n", filename);
2305     }
2306
2307     puts("\n*** wxFileInputStream test done ***");
2308 }
2309
2310 static void TestMemoryStream()
2311 {
2312     puts("*** Testing wxMemoryInputStream ***");
2313
2314     wxChar buf[1024];
2315     wxStrncpy(buf, _T("Hello, stream!"), WXSIZEOF(buf));
2316
2317     wxMemoryInputStream memInpStream(buf, wxStrlen(buf));
2318     printf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
2319     while ( !memInpStream.Eof() )
2320     {
2321         putchar(memInpStream.GetC());
2322     }
2323
2324     puts("\n*** wxMemoryInputStream test done ***");
2325 }
2326
2327 #endif // TEST_STREAMS
2328
2329 // ----------------------------------------------------------------------------
2330 // timers
2331 // ----------------------------------------------------------------------------
2332
2333 #ifdef TEST_TIMER
2334
2335 #include <wx/timer.h>
2336 #include <wx/utils.h>
2337
2338 static void TestStopWatch()
2339 {
2340     puts("*** Testing wxStopWatch ***\n");
2341
2342     wxStopWatch sw;
2343     printf("Sleeping 3 seconds...");
2344     wxSleep(3);
2345     printf("\telapsed time: %ldms\n", sw.Time());
2346
2347     sw.Pause();
2348     printf("Sleeping 2 more seconds...");
2349     wxSleep(2);
2350     printf("\telapsed time: %ldms\n", sw.Time());
2351
2352     sw.Resume();
2353     printf("And 3 more seconds...");
2354     wxSleep(3);
2355     printf("\telapsed time: %ldms\n", sw.Time());
2356
2357     wxStopWatch sw2;
2358     puts("\nChecking for 'backwards clock' bug...");
2359     for ( size_t n = 0; n < 70; n++ )
2360     {
2361         sw2.Start();
2362
2363         for ( size_t m = 0; m < 100000; m++ )
2364         {
2365             if ( sw.Time() < 0 || sw2.Time() < 0 )
2366             {
2367                 puts("\ntime is negative - ERROR!");
2368             }
2369         }
2370
2371         putchar('.');
2372     }
2373
2374     puts(", ok.");
2375 }
2376
2377 #endif // TEST_TIMER
2378
2379 // ----------------------------------------------------------------------------
2380 // vCard support
2381 // ----------------------------------------------------------------------------
2382
2383 #ifdef TEST_VCARD
2384
2385 #include <wx/vcard.h>
2386
2387 static void DumpVObject(size_t level, const wxVCardObject& vcard)
2388 {
2389     void *cookie;
2390     wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
2391     while ( vcObj )
2392     {
2393         printf("%s%s",
2394                wxString(_T('\t'), level).c_str(),
2395                vcObj->GetName().c_str());
2396
2397         wxString value;
2398         switch ( vcObj->GetType() )
2399         {
2400             case wxVCardObject::String:
2401             case wxVCardObject::UString:
2402                 {
2403                     wxString val;
2404                     vcObj->GetValue(&val);
2405                     value << _T('"') << val << _T('"');
2406                 }
2407                 break;
2408
2409             case wxVCardObject::Int:
2410                 {
2411                     unsigned int i;
2412                     vcObj->GetValue(&i);
2413                     value.Printf(_T("%u"), i);
2414                 }
2415                 break;
2416
2417             case wxVCardObject::Long:
2418                 {
2419                     unsigned long l;
2420                     vcObj->GetValue(&l);
2421                     value.Printf(_T("%lu"), l);
2422                 }
2423                 break;
2424
2425             case wxVCardObject::None:
2426                 break;
2427
2428             case wxVCardObject::Object:
2429                 value = _T("<node>");
2430                 break;
2431
2432             default:
2433                 value = _T("<unknown value type>");
2434         }
2435
2436         if ( !!value )
2437             printf(" = %s", value.c_str());
2438         putchar('\n');
2439
2440         DumpVObject(level + 1, *vcObj);
2441
2442         delete vcObj;
2443         vcObj = vcard.GetNextProp(&cookie);
2444     }
2445 }
2446
2447 static void DumpVCardAddresses(const wxVCard& vcard)
2448 {
2449     puts("\nShowing all addresses from vCard:\n");
2450
2451     size_t nAdr = 0;
2452     void *cookie;
2453     wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
2454     while ( addr )
2455     {
2456         wxString flagsStr;
2457         int flags = addr->GetFlags();
2458         if ( flags & wxVCardAddress::Domestic )
2459         {
2460             flagsStr << _T("domestic ");
2461         }
2462         if ( flags & wxVCardAddress::Intl )
2463         {
2464             flagsStr << _T("international ");
2465         }
2466         if ( flags & wxVCardAddress::Postal )
2467         {
2468             flagsStr << _T("postal ");
2469         }
2470         if ( flags & wxVCardAddress::Parcel )
2471         {
2472             flagsStr << _T("parcel ");
2473         }
2474         if ( flags & wxVCardAddress::Home )
2475         {
2476             flagsStr << _T("home ");
2477         }
2478         if ( flags & wxVCardAddress::Work )
2479         {
2480             flagsStr << _T("work ");
2481         }
2482
2483         printf("Address %u:\n"
2484                "\tflags = %s\n"
2485                "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
2486                ++nAdr,
2487                flagsStr.c_str(),
2488                addr->GetPostOffice().c_str(),
2489                addr->GetExtAddress().c_str(),
2490                addr->GetStreet().c_str(),
2491                addr->GetLocality().c_str(),
2492                addr->GetRegion().c_str(),
2493                addr->GetPostalCode().c_str(),
2494                addr->GetCountry().c_str()
2495                );
2496
2497         delete addr;
2498         addr = vcard.GetNextAddress(&cookie);
2499     }
2500 }
2501
2502 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
2503 {
2504     puts("\nShowing all phone numbers from vCard:\n");
2505
2506     size_t nPhone = 0;
2507     void *cookie;
2508     wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
2509     while ( phone )
2510     {
2511         wxString flagsStr;
2512         int flags = phone->GetFlags();
2513         if ( flags & wxVCardPhoneNumber::Voice )
2514         {
2515             flagsStr << _T("voice ");
2516         }
2517         if ( flags & wxVCardPhoneNumber::Fax )
2518         {
2519             flagsStr << _T("fax ");
2520         }
2521         if ( flags & wxVCardPhoneNumber::Cellular )
2522         {
2523             flagsStr << _T("cellular ");
2524         }
2525         if ( flags & wxVCardPhoneNumber::Modem )
2526         {
2527             flagsStr << _T("modem ");
2528         }
2529         if ( flags & wxVCardPhoneNumber::Home )
2530         {
2531             flagsStr << _T("home ");
2532         }
2533         if ( flags & wxVCardPhoneNumber::Work )
2534         {
2535             flagsStr << _T("work ");
2536         }
2537
2538         printf("Phone number %u:\n"
2539                "\tflags = %s\n"
2540                "\tvalue = %s\n",
2541                ++nPhone,
2542                flagsStr.c_str(),
2543                phone->GetNumber().c_str()
2544                );
2545
2546         delete phone;
2547         phone = vcard.GetNextPhoneNumber(&cookie);
2548     }
2549 }
2550
2551 static void TestVCardRead()
2552 {
2553     puts("*** Testing wxVCard reading ***\n");
2554
2555     wxVCard vcard(_T("vcard.vcf"));
2556     if ( !vcard.IsOk() )
2557     {
2558         puts("ERROR: couldn't load vCard.");
2559     }
2560     else
2561     {
2562         // read individual vCard properties
2563         wxVCardObject *vcObj = vcard.GetProperty("FN");
2564         wxString value;
2565         if ( vcObj )
2566         {
2567             vcObj->GetValue(&value);
2568             delete vcObj;
2569         }
2570         else
2571         {
2572             value = _T("<none>");
2573         }
2574
2575         printf("Full name retrieved directly: %s\n", value.c_str());
2576
2577
2578         if ( !vcard.GetFullName(&value) )
2579         {
2580             value = _T("<none>");
2581         }
2582
2583         printf("Full name from wxVCard API: %s\n", value.c_str());
2584
2585         // now show how to deal with multiply occuring properties
2586         DumpVCardAddresses(vcard);
2587         DumpVCardPhoneNumbers(vcard);
2588
2589         // and finally show all
2590         puts("\nNow dumping the entire vCard:\n"
2591              "-----------------------------\n");
2592
2593         DumpVObject(0, vcard);
2594     }
2595 }
2596
2597 static void TestVCardWrite()
2598 {
2599     puts("*** Testing wxVCard writing ***\n");
2600
2601     wxVCard vcard;
2602     if ( !vcard.IsOk() )
2603     {
2604         puts("ERROR: couldn't create vCard.");
2605     }
2606     else
2607     {
2608         // set some fields
2609         vcard.SetName("Zeitlin", "Vadim");
2610         vcard.SetFullName("Vadim Zeitlin");
2611         vcard.SetOrganization("wxWindows", "R&D");
2612
2613         // just dump the vCard back
2614         puts("Entire vCard follows:\n");
2615         puts(vcard.Write());
2616     }
2617 }
2618
2619 #endif // TEST_VCARD
2620
2621 // ----------------------------------------------------------------------------
2622 // wide char (Unicode) support
2623 // ----------------------------------------------------------------------------
2624
2625 #ifdef TEST_WCHAR
2626
2627 #include <wx/strconv.h>
2628 #include <wx/fontenc.h>
2629 #include <wx/encconv.h>
2630 #include <wx/buffer.h>
2631
2632 static void TestUtf8()
2633 {
2634     puts("*** Testing UTF8 support ***\n");
2635
2636     static const char textInUtf8[] =
2637     {
2638         208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
2639         208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
2640         176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
2641         208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
2642         181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
2643         208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
2644         178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
2645     };
2646
2647     char buf[1024];
2648     wchar_t wbuf[1024];
2649     if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
2650     {
2651         puts("ERROR: UTF-8 decoding failed.");
2652     }
2653     else
2654     {
2655         // using wxEncodingConverter
2656 #if 0
2657         wxEncodingConverter ec;
2658         ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
2659         ec.Convert(wbuf, buf);
2660 #else // using wxCSConv
2661         wxCSConv conv(_T("koi8-r"));
2662         if ( conv.WC2MB(buf, wbuf, 0 /* not needed wcslen(wbuf) */) <= 0 )
2663         {
2664             puts("ERROR: conversion to KOI8-R failed.");
2665         }
2666         else
2667 #endif
2668
2669         printf("The resulting string (in koi8-r): %s\n", buf);
2670     }
2671 }
2672
2673 #endif // TEST_WCHAR
2674
2675 // ----------------------------------------------------------------------------
2676 // ZIP stream
2677 // ----------------------------------------------------------------------------
2678
2679 #ifdef TEST_ZIP
2680
2681 #include "wx/filesys.h"
2682 #include "wx/fs_zip.h"
2683 #include "wx/zipstrm.h"
2684
2685 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
2686
2687 static void TestZipStreamRead()
2688 {
2689     puts("*** Testing ZIP reading ***\n");
2690
2691     static const wxChar *filename = _T("foo");
2692     wxZipInputStream istr(TESTFILE_ZIP, filename);
2693     printf("Archive size: %u\n", istr.GetSize());
2694
2695     printf("Dumping the file '%s':\n", filename);
2696     while ( !istr.Eof() )
2697     {
2698         putchar(istr.GetC());
2699         fflush(stdout);
2700     }
2701
2702     puts("\n----- done ------");
2703 }
2704
2705 static void DumpZipDirectory(wxFileSystem& fs,
2706                              const wxString& dir,
2707                              const wxString& indent)
2708 {
2709     wxString prefix = wxString::Format(_T("%s#zip:%s"),
2710                                          TESTFILE_ZIP, dir.c_str());
2711     wxString wildcard = prefix + _T("/*");
2712
2713     wxString dirname = fs.FindFirst(wildcard, wxDIR);
2714     while ( !dirname.empty() )
2715     {
2716         if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
2717         {
2718             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
2719
2720             break;
2721         }
2722
2723         wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
2724
2725         DumpZipDirectory(fs, dirname,
2726                          indent + wxString(_T(' '), 4));
2727
2728         dirname = fs.FindNext();
2729     }
2730
2731     wxString filename = fs.FindFirst(wildcard, wxFILE);
2732     while ( !filename.empty() )
2733     {
2734         if ( !filename.StartsWith(prefix, &filename) )
2735         {
2736             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
2737
2738             break;
2739         }
2740
2741         wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
2742
2743         filename = fs.FindNext();
2744     }
2745 }
2746
2747 static void TestZipFileSystem()
2748 {
2749     puts("*** Testing ZIP file system ***\n");
2750
2751     wxFileSystem::AddHandler(new wxZipFSHandler);
2752     wxFileSystem fs;
2753     wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
2754
2755     DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
2756 }
2757
2758 #endif // TEST_ZIP
2759
2760 // ----------------------------------------------------------------------------
2761 // ZLIB stream
2762 // ----------------------------------------------------------------------------
2763
2764 #ifdef TEST_ZLIB
2765
2766 #include <wx/zstream.h>
2767 #include <wx/wfstream.h>
2768
2769 static const wxChar *FILENAME_GZ = _T("test.gz");
2770 static const char *TEST_DATA = "hello and hello again";
2771
2772 static void TestZlibStreamWrite()
2773 {
2774     puts("*** Testing Zlib stream reading ***\n");
2775
2776     wxFileOutputStream fileOutStream(FILENAME_GZ);
2777     wxZlibOutputStream ostr(fileOutStream, 0);
2778     printf("Compressing the test string... ");
2779     ostr.Write(TEST_DATA, sizeof(TEST_DATA));
2780     if ( !ostr )
2781     {
2782         puts("(ERROR: failed)");
2783     }
2784     else
2785     {
2786         puts("(ok)");
2787     }
2788
2789     puts("\n----- done ------");
2790 }
2791
2792 static void TestZlibStreamRead()
2793 {
2794     puts("*** Testing Zlib stream reading ***\n");
2795
2796     wxFileInputStream fileInStream(FILENAME_GZ);
2797     wxZlibInputStream istr(fileInStream);
2798     printf("Archive size: %u\n", istr.GetSize());
2799
2800     puts("Dumping the file:");
2801     while ( !istr.Eof() )
2802     {
2803         putchar(istr.GetC());
2804         fflush(stdout);
2805     }
2806
2807     puts("\n----- done ------");
2808 }
2809
2810 #endif // TEST_ZLIB
2811
2812 // ----------------------------------------------------------------------------
2813 // date time
2814 // ----------------------------------------------------------------------------
2815
2816 #ifdef TEST_DATETIME
2817
2818 #include <math.h>
2819
2820 #include <wx/date.h>
2821
2822 #include <wx/datetime.h>
2823
2824 // the test data
2825 struct Date
2826 {
2827     wxDateTime::wxDateTime_t day;
2828     wxDateTime::Month month;
2829     int year;
2830     wxDateTime::wxDateTime_t hour, min, sec;
2831     double jdn;
2832     wxDateTime::WeekDay wday;
2833     time_t gmticks, ticks;
2834
2835     void Init(const wxDateTime::Tm& tm)
2836     {
2837         day = tm.mday;
2838         month = tm.mon;
2839         year = tm.year;
2840         hour = tm.hour;
2841         min = tm.min;
2842         sec = tm.sec;
2843         jdn = 0.0;
2844         gmticks = ticks = -1;
2845     }
2846
2847     wxDateTime DT() const
2848         { return wxDateTime(day, month, year, hour, min, sec); }
2849
2850     bool SameDay(const wxDateTime::Tm& tm) const
2851     {
2852         return day == tm.mday && month == tm.mon && year == tm.year;
2853     }
2854
2855     wxString Format() const
2856     {
2857         wxString s;
2858         s.Printf("%02d:%02d:%02d %10s %02d, %4d%s",
2859                  hour, min, sec,
2860                  wxDateTime::GetMonthName(month).c_str(),
2861                  day,
2862                  abs(wxDateTime::ConvertYearToBC(year)),
2863                  year > 0 ? "AD" : "BC");
2864         return s;
2865     }
2866
2867     wxString FormatDate() const
2868     {
2869         wxString s;
2870         s.Printf("%02d-%s-%4d%s",
2871                  day,
2872                  wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
2873                  abs(wxDateTime::ConvertYearToBC(year)),
2874                  year > 0 ? "AD" : "BC");
2875         return s;
2876     }
2877 };
2878
2879 static const Date testDates[] =
2880 {
2881     {  1, wxDateTime::Jan,  1970, 00, 00, 00, 2440587.5, wxDateTime::Thu,         0,     -3600 },
2882     { 21, wxDateTime::Jan,  2222, 00, 00, 00, 2532648.5, wxDateTime::Mon,        -1,        -1 },
2883     { 29, wxDateTime::May,  1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
2884     { 29, wxDateTime::Feb,  1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
2885     {  1, wxDateTime::Jan,  1900, 12, 00, 00, 2415021.0, wxDateTime::Mon,        -1,        -1 },
2886     {  1, wxDateTime::Jan,  1900, 00, 00, 00, 2415020.5, wxDateTime::Mon,        -1,        -1 },
2887     { 15, wxDateTime::Oct,  1582, 00, 00, 00, 2299160.5, wxDateTime::Fri,        -1,        -1 },
2888     {  4, wxDateTime::Oct,  1582, 00, 00, 00, 2299149.5, wxDateTime::Mon,        -1,        -1 },
2889     {  1, wxDateTime::Mar,     1, 00, 00, 00, 1721484.5, wxDateTime::Thu,        -1,        -1 },
2890     {  1, wxDateTime::Jan,     1, 00, 00, 00, 1721425.5, wxDateTime::Mon,        -1,        -1 },
2891     { 31, wxDateTime::Dec,     0, 00, 00, 00, 1721424.5, wxDateTime::Sun,        -1,        -1 },
2892     {  1, wxDateTime::Jan,     0, 00, 00, 00, 1721059.5, wxDateTime::Sat,        -1,        -1 },
2893     { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri,        -1,        -1 },
2894     { 12, wxDateTime::Aug, -4000, 00, 00, 00,  260313.5, wxDateTime::Sat,        -1,        -1 },
2895     { 24, wxDateTime::Nov, -4713, 00, 00, 00,      -0.5, wxDateTime::Mon,        -1,        -1 },
2896 };
2897
2898 // this test miscellaneous static wxDateTime functions
2899 static void TestTimeStatic()
2900 {
2901     puts("\n*** wxDateTime static methods test ***");
2902
2903     // some info about the current date
2904     int year = wxDateTime::GetCurrentYear();
2905     printf("Current year %d is %sa leap one and has %d days.\n",
2906            year,
2907            wxDateTime::IsLeapYear(year) ? "" : "not ",
2908            wxDateTime::GetNumberOfDays(year));
2909
2910     wxDateTime::Month month = wxDateTime::GetCurrentMonth();
2911     printf("Current month is '%s' ('%s') and it has %d days\n",
2912            wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
2913            wxDateTime::GetMonthName(month).c_str(),
2914            wxDateTime::GetNumberOfDays(month));
2915
2916     // leap year logic
2917     static const size_t nYears = 5;
2918     static const size_t years[2][nYears] =
2919     {
2920         // first line: the years to test
2921         { 1990, 1976, 2000, 2030, 1984, },
2922
2923         // second line: TRUE if leap, FALSE otherwise
2924         { FALSE, TRUE, TRUE, FALSE, TRUE }
2925     };
2926
2927     for ( size_t n = 0; n < nYears; n++ )
2928     {
2929         int year = years[0][n];
2930         bool should = years[1][n] != 0,
2931              is = wxDateTime::IsLeapYear(year);
2932
2933         printf("Year %d is %sa leap year (%s)\n",
2934                year,
2935                is ? "" : "not ",
2936                should == is ? "ok" : "ERROR");
2937
2938         wxASSERT( should == wxDateTime::IsLeapYear(year) );
2939     }
2940 }
2941
2942 // test constructing wxDateTime objects
2943 static void TestTimeSet()
2944 {
2945     puts("\n*** wxDateTime construction test ***");
2946
2947     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
2948     {
2949         const Date& d1 = testDates[n];
2950         wxDateTime dt = d1.DT();
2951
2952         Date d2;
2953         d2.Init(dt.GetTm());
2954
2955         wxString s1 = d1.Format(),
2956                  s2 = d2.Format();
2957
2958         printf("Date: %s == %s (%s)\n",
2959                s1.c_str(), s2.c_str(),
2960                s1 == s2 ? "ok" : "ERROR");
2961     }
2962 }
2963
2964 // test time zones stuff
2965 static void TestTimeZones()
2966 {
2967     puts("\n*** wxDateTime timezone test ***");
2968
2969     wxDateTime now = wxDateTime::Now();
2970
2971     printf("Current GMT time:\t%s\n", now.Format("%c", wxDateTime::GMT0).c_str());
2972     printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::GMT0).c_str());
2973     printf("Unix epoch (EST):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::EST).c_str());
2974     printf("Current time in Paris:\t%s\n", now.Format("%c", wxDateTime::CET).c_str());
2975     printf("               Moscow:\t%s\n", now.Format("%c", wxDateTime::MSK).c_str());
2976     printf("             New York:\t%s\n", now.Format("%c", wxDateTime::EST).c_str());
2977
2978     wxDateTime::Tm tm = now.GetTm();
2979     if ( wxDateTime(tm) != now )
2980     {
2981         printf("ERROR: got %s instead of %s\n",
2982                wxDateTime(tm).Format().c_str(), now.Format().c_str());
2983     }
2984 }
2985
2986 // test some minimal support for the dates outside the standard range
2987 static void TestTimeRange()
2988 {
2989     puts("\n*** wxDateTime out-of-standard-range dates test ***");
2990
2991     static const char *fmt = "%d-%b-%Y %H:%M:%S";
2992
2993     printf("Unix epoch:\t%s\n",
2994            wxDateTime(2440587.5).Format(fmt).c_str());
2995     printf("Feb 29, 0: \t%s\n",
2996             wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
2997     printf("JDN 0:     \t%s\n",
2998             wxDateTime(0.0).Format(fmt).c_str());
2999     printf("Jan 1, 1AD:\t%s\n",
3000             wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3001     printf("May 29, 2099:\t%s\n",
3002             wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
3003 }
3004
3005 static void TestTimeTicks()
3006 {
3007     puts("\n*** wxDateTime ticks test ***");
3008
3009     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
3010     {
3011         const Date& d = testDates[n];
3012         if ( d.ticks == -1 )
3013             continue;
3014
3015         wxDateTime dt = d.DT();
3016         long ticks = (dt.GetValue() / 1000).ToLong();
3017         printf("Ticks of %s:\t% 10ld", d.Format().c_str(), ticks);
3018         if ( ticks == d.ticks )
3019         {
3020             puts(" (ok)");
3021         }
3022         else
3023         {
3024             printf(" (ERROR: should be %ld, delta = %ld)\n",
3025                    d.ticks, ticks - d.ticks);
3026         }
3027
3028         dt = d.DT().ToTimezone(wxDateTime::GMT0);
3029         ticks = (dt.GetValue() / 1000).ToLong();
3030         printf("GMtks of %s:\t% 10ld", d.Format().c_str(), ticks);
3031         if ( ticks == d.gmticks )
3032         {
3033             puts(" (ok)");
3034         }
3035         else
3036         {
3037             printf(" (ERROR: should be %ld, delta = %ld)\n",
3038                    d.gmticks, ticks - d.gmticks);
3039         }
3040     }
3041
3042     puts("");
3043 }
3044
3045 // test conversions to JDN &c
3046 static void TestTimeJDN()
3047 {
3048     puts("\n*** wxDateTime to JDN test ***");
3049
3050     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
3051     {
3052         const Date& d = testDates[n];
3053         wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
3054         double jdn = dt.GetJulianDayNumber();
3055
3056         printf("JDN of %s is:\t% 15.6f", d.Format().c_str(), jdn);
3057         if ( jdn == d.jdn )
3058         {
3059             puts(" (ok)");
3060         }
3061         else
3062         {
3063             printf(" (ERROR: should be %f, delta = %f)\n",
3064                    d.jdn, jdn - d.jdn);
3065         }
3066     }
3067 }
3068
3069 // test week days computation
3070 static void TestTimeWDays()
3071 {
3072     puts("\n*** wxDateTime weekday test ***");
3073
3074     // test GetWeekDay()
3075     size_t n;
3076     for ( n = 0; n < WXSIZEOF(testDates); n++ )
3077     {
3078         const Date& d = testDates[n];
3079         wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
3080
3081         wxDateTime::WeekDay wday = dt.GetWeekDay();
3082         printf("%s is: %s",
3083                d.Format().c_str(),
3084                wxDateTime::GetWeekDayName(wday).c_str());
3085         if ( wday == d.wday )
3086         {
3087             puts(" (ok)");
3088         }
3089         else
3090         {
3091             printf(" (ERROR: should be %s)\n",
3092                    wxDateTime::GetWeekDayName(d.wday).c_str());
3093         }
3094     }
3095
3096     puts("");
3097
3098     // test SetToWeekDay()
3099     struct WeekDateTestData
3100     {
3101         Date date;                  // the real date (precomputed)
3102         int nWeek;                  // its week index in the month
3103         wxDateTime::WeekDay wday;   // the weekday
3104         wxDateTime::Month month;    // the month
3105         int year;                   // and the year
3106
3107         wxString Format() const
3108         {
3109             wxString s, which;
3110             switch ( nWeek < -1 ? -nWeek : nWeek )
3111             {
3112                 case 1: which = "first"; break;
3113                 case 2: which = "second"; break;
3114                 case 3: which = "third"; break;
3115                 case 4: which = "fourth"; break;
3116                 case 5: which = "fifth"; break;
3117
3118                 case -1: which = "last"; break;
3119             }
3120
3121             if ( nWeek < -1 )
3122             {
3123                 which += " from end";
3124             }
3125
3126             s.Printf("The %s %s of %s in %d",
3127                      which.c_str(),
3128                      wxDateTime::GetWeekDayName(wday).c_str(),
3129                      wxDateTime::GetMonthName(month).c_str(),
3130                      year);
3131
3132             return s;
3133         }
3134     };
3135
3136     // the array data was generated by the following python program
3137     /*
3138 from DateTime import *
3139 from whrandom import *
3140 from string import *
3141
3142 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
3143 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
3144
3145 week = DateTimeDelta(7)
3146
3147 for n in range(20):
3148     year = randint(1900, 2100)
3149     month = randint(1, 12)
3150     day = randint(1, 28)
3151     dt = DateTime(year, month, day)
3152     wday = dt.day_of_week
3153
3154     countFromEnd = choice([-1, 1])
3155     weekNum = 0;
3156
3157     while dt.month is month:
3158         dt = dt - countFromEnd * week
3159         weekNum = weekNum + countFromEnd
3160
3161     data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
3162
3163     print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
3164           "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
3165     */
3166
3167     static const WeekDateTestData weekDatesTestData[] =
3168     {
3169         { { 20, wxDateTime::Mar, 2045 },  3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
3170         { {  5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
3171         { { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
3172         { { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
3173         { {  4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
3174         { {  2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
3175         { { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
3176         { {  5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
3177         { { 11, wxDateTime::Aug, 1900 },  2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
3178         { { 14, wxDateTime::Feb, 1945 },  2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
3179         { { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
3180         { {  9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
3181         { { 20, wxDateTime::Jun, 1927 },  3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
3182         { {  2, wxDateTime::Aug, 2000 },  1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
3183         { { 20, wxDateTime::Apr, 2044 },  3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
3184         { { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
3185         { { 25, wxDateTime::Jul, 2069 },  4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
3186         { {  3, wxDateTime::Apr, 1925 },  1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
3187         { { 21, wxDateTime::Mar, 2093 },  3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
3188         { {  3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
3189     };
3190
3191     static const char *fmt = "%d-%b-%Y";
3192
3193     wxDateTime dt;
3194     for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
3195     {
3196         const WeekDateTestData& wd = weekDatesTestData[n];
3197
3198         dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
3199
3200         printf("%s is %s", wd.Format().c_str(), dt.Format(fmt).c_str());
3201
3202         const Date& d = wd.date;
3203         if ( d.SameDay(dt.GetTm()) )
3204         {
3205             puts(" (ok)");
3206         }
3207         else
3208         {
3209             dt.Set(d.day, d.month, d.year);
3210
3211             printf(" (ERROR: should be %s)\n", dt.Format(fmt).c_str());
3212         }
3213     }
3214 }
3215
3216 // test the computation of (ISO) week numbers
3217 static void TestTimeWNumber()
3218 {
3219     puts("\n*** wxDateTime week number test ***");
3220
3221     struct WeekNumberTestData
3222     {
3223         Date date;                          // the date
3224         wxDateTime::wxDateTime_t week;      // the week number in the year
3225         wxDateTime::wxDateTime_t wmon;      // the week number in the month
3226         wxDateTime::wxDateTime_t wmon2;     // same but week starts with Sun
3227         wxDateTime::wxDateTime_t dnum;      // day number in the year
3228     };
3229
3230     // data generated with the following python script:
3231     /*
3232 from DateTime import *
3233 from whrandom import *
3234 from string import *
3235
3236 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
3237 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
3238
3239 def GetMonthWeek(dt):
3240     weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
3241     if weekNumMonth < 0:
3242         weekNumMonth = weekNumMonth + 53
3243     return weekNumMonth
3244
3245 def GetLastSundayBefore(dt):
3246     if dt.iso_week[2] == 7:
3247         return dt
3248     else:
3249         return dt - DateTimeDelta(dt.iso_week[2])
3250
3251 for n in range(20):
3252     year = randint(1900, 2100)
3253     month = randint(1, 12)
3254     day = randint(1, 28)
3255     dt = DateTime(year, month, day)
3256     dayNum = dt.day_of_year
3257     weekNum = dt.iso_week[1]
3258     weekNumMonth = GetMonthWeek(dt)
3259
3260     weekNumMonth2 = 0
3261     dtSunday = GetLastSundayBefore(dt)
3262
3263     while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
3264         weekNumMonth2 = weekNumMonth2 + 1
3265         dtSunday = dtSunday - DateTimeDelta(7)
3266
3267     data = { 'day': rjust(`day`, 2), \
3268              'month': monthNames[month - 1], \
3269              'year': year, \
3270              'weekNum': rjust(`weekNum`, 2), \
3271              'weekNumMonth': weekNumMonth, \
3272              'weekNumMonth2': weekNumMonth2, \
3273              'dayNum': rjust(`dayNum`, 3) }
3274
3275     print "        { { %(day)s, "\
3276           "wxDateTime::%(month)s, "\
3277           "%(year)d }, "\
3278           "%(weekNum)s, "\
3279           "%(weekNumMonth)s, "\
3280           "%(weekNumMonth2)s, "\
3281           "%(dayNum)s }," % data
3282
3283     */
3284     static const WeekNumberTestData weekNumberTestDates[] =
3285     {
3286         { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
3287         { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
3288         { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
3289         { {  1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
3290         { {  8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
3291         { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4,  81 },
3292         { {  7, wxDateTime::Jan, 1965 },  1, 2, 2,   7 },
3293         { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
3294         { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
3295         { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
3296         { {  2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
3297         { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
3298         { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
3299         { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
3300         { {  3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
3301         { { 23, wxDateTime::Feb, 1940 },  8, 4, 4,  54 },
3302         { {  2, wxDateTime::Jan, 1987 },  1, 1, 1,   2 },
3303         { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
3304         { {  2, wxDateTime::Feb, 2063 },  5, 1, 1,  33 },
3305         { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
3306     };
3307
3308     for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
3309     {
3310         const WeekNumberTestData& wn = weekNumberTestDates[n];
3311         const Date& d = wn.date;
3312
3313         wxDateTime dt = d.DT();
3314
3315         wxDateTime::wxDateTime_t
3316             week = dt.GetWeekOfYear(wxDateTime::Monday_First),
3317             wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
3318             wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3319             dnum = dt.GetDayOfYear();
3320
3321         printf("%s: the day number is %d",
3322                d.FormatDate().c_str(), dnum);
3323         if ( dnum == wn.dnum )
3324         {
3325             printf(" (ok)");
3326         }
3327         else
3328         {
3329             printf(" (ERROR: should be %d)", wn.dnum);
3330         }
3331
3332         printf(", week in month is %d", wmon);
3333         if ( wmon == wn.wmon )
3334         {
3335             printf(" (ok)");
3336         }
3337         else
3338         {
3339             printf(" (ERROR: should be %d)", wn.wmon);
3340         }
3341
3342         printf(" or %d", wmon2);
3343         if ( wmon2 == wn.wmon2 )
3344         {
3345             printf(" (ok)");
3346         }
3347         else
3348         {
3349             printf(" (ERROR: should be %d)", wn.wmon2);
3350         }
3351
3352         printf(", week in year is %d", week);
3353         if ( week == wn.week )
3354         {
3355             puts(" (ok)");
3356         }
3357         else
3358         {
3359             printf(" (ERROR: should be %d)\n", wn.week);
3360         }
3361     }
3362 }
3363
3364 // test DST calculations
3365 static void TestTimeDST()
3366 {
3367     puts("\n*** wxDateTime DST test ***");
3368
3369     printf("DST is%s in effect now.\n\n",
3370            wxDateTime::Now().IsDST() ? "" : " not");
3371
3372     // taken from http://www.energy.ca.gov/daylightsaving.html
3373     static const Date datesDST[2][2004 - 1900 + 1] =
3374     {
3375         {
3376             { 1, wxDateTime::Apr, 1990 },
3377             { 7, wxDateTime::Apr, 1991 },
3378             { 5, wxDateTime::Apr, 1992 },
3379             { 4, wxDateTime::Apr, 1993 },
3380             { 3, wxDateTime::Apr, 1994 },
3381             { 2, wxDateTime::Apr, 1995 },
3382             { 7, wxDateTime::Apr, 1996 },
3383             { 6, wxDateTime::Apr, 1997 },
3384             { 5, wxDateTime::Apr, 1998 },
3385             { 4, wxDateTime::Apr, 1999 },
3386             { 2, wxDateTime::Apr, 2000 },
3387             { 1, wxDateTime::Apr, 2001 },
3388             { 7, wxDateTime::Apr, 2002 },
3389             { 6, wxDateTime::Apr, 2003 },
3390             { 4, wxDateTime::Apr, 2004 },
3391         },
3392         {
3393             { 28, wxDateTime::Oct, 1990 },
3394             { 27, wxDateTime::Oct, 1991 },
3395             { 25, wxDateTime::Oct, 1992 },
3396             { 31, wxDateTime::Oct, 1993 },
3397             { 30, wxDateTime::Oct, 1994 },
3398             { 29, wxDateTime::Oct, 1995 },
3399             { 27, wxDateTime::Oct, 1996 },
3400             { 26, wxDateTime::Oct, 1997 },
3401             { 25, wxDateTime::Oct, 1998 },
3402             { 31, wxDateTime::Oct, 1999 },
3403             { 29, wxDateTime::Oct, 2000 },
3404             { 28, wxDateTime::Oct, 2001 },
3405             { 27, wxDateTime::Oct, 2002 },
3406             { 26, wxDateTime::Oct, 2003 },
3407             { 31, wxDateTime::Oct, 2004 },
3408         }
3409     };
3410
3411     int year;
3412     for ( year = 1990; year < 2005; year++ )
3413     {
3414         wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
3415                    dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
3416
3417         printf("DST period in the US for year %d: from %s to %s",
3418                year, dtBegin.Format().c_str(), dtEnd.Format().c_str());
3419
3420         size_t n = year - 1990;
3421         const Date& dBegin = datesDST[0][n];
3422         const Date& dEnd = datesDST[1][n];
3423
3424         if ( dBegin.SameDay(dtBegin.GetTm()) && dEnd.SameDay(dtEnd.GetTm()) )
3425         {
3426             puts(" (ok)");
3427         }
3428         else
3429         {
3430             printf(" (ERROR: should be %s %d to %s %d)\n",
3431                     wxDateTime::GetMonthName(dBegin.month).c_str(), dBegin.day,
3432                     wxDateTime::GetMonthName(dEnd.month).c_str(), dEnd.day);
3433         }
3434     }
3435
3436     puts("");
3437
3438     for ( year = 1990; year < 2005; year++ )
3439     {
3440         printf("DST period in Europe for year %d: from %s to %s\n",
3441                year,
3442                wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3443                wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
3444     }
3445 }
3446
3447 // test wxDateTime -> text conversion
3448 static void TestTimeFormat()
3449 {
3450     puts("\n*** wxDateTime formatting test ***");
3451
3452     // some information may be lost during conversion, so store what kind
3453     // of info should we recover after a round trip
3454     enum CompareKind
3455     {
3456         CompareNone,        // don't try comparing
3457         CompareBoth,        // dates and times should be identical
3458         CompareDate,        // dates only
3459         CompareTime         // time only
3460     };
3461
3462     static const struct
3463     {
3464         CompareKind compareKind;
3465         const char *format;
3466     } formatTestFormats[] =
3467     {
3468        { CompareBoth, "---> %c" },
3469        { CompareDate, "Date is %A, %d of %B, in year %Y" },
3470        { CompareBoth, "Date is %x, time is %X" },
3471        { CompareTime, "Time is %H:%M:%S or %I:%M:%S %p" },
3472        { CompareNone, "The day of year: %j, the week of year: %W" },
3473        { CompareDate, "ISO date without separators: %4Y%2m%2d" },
3474     };
3475
3476     static const Date formatTestDates[] =
3477     {
3478         { 29, wxDateTime::May, 1976, 18, 30, 00 },
3479         { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
3480 #if 0
3481         // this test can't work for other centuries because it uses two digit
3482         // years in formats, so don't even try it
3483         { 29, wxDateTime::May, 2076, 18, 30, 00 },
3484         { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
3485         { 01, wxDateTime::Jan,  -52, 03, 16, 47 },
3486 #endif
3487     };
3488
3489     // an extra test (as it doesn't depend on date, don't do it in the loop)
3490     printf("%s\n", wxDateTime::Now().Format("Our timezone is %Z").c_str());
3491
3492     for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
3493     {
3494         puts("");
3495
3496         wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
3497         for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
3498         {
3499             wxString s = dt.Format(formatTestFormats[n].format);
3500             printf("%s", s.c_str());
3501
3502             // what can we recover?
3503             int kind = formatTestFormats[n].compareKind;
3504
3505             // convert back
3506             wxDateTime dt2;
3507             const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
3508             if ( !result )
3509             {
3510                 // converion failed - should it have?
3511                 if ( kind == CompareNone )
3512                     puts(" (ok)");
3513                 else
3514                     puts(" (ERROR: conversion back failed)");
3515             }
3516             else if ( *result )
3517             {
3518                 // should have parsed the entire string
3519                 puts(" (ERROR: conversion back stopped too soon)");
3520             }
3521             else
3522             {
3523                 bool equal = FALSE; // suppress compilaer warning
3524                 switch ( kind )
3525                 {
3526                     case CompareBoth:
3527                         equal = dt2 == dt;
3528                         break;
3529
3530                     case CompareDate:
3531                         equal = dt.IsSameDate(dt2);
3532                         break;
3533
3534                     case CompareTime:
3535                         equal = dt.IsSameTime(dt2);
3536                         break;
3537                 }
3538
3539                 if ( !equal )
3540                 {
3541                     printf(" (ERROR: got back '%s' instead of '%s')\n",
3542                            dt2.Format().c_str(), dt.Format().c_str());
3543                 }
3544                 else
3545                 {
3546                     puts(" (ok)");
3547                 }
3548             }
3549         }
3550     }
3551 }
3552
3553 // test text -> wxDateTime conversion
3554 static void TestTimeParse()
3555 {
3556     puts("\n*** wxDateTime parse test ***");
3557
3558     struct ParseTestData
3559     {
3560         const char *format;
3561         Date date;
3562         bool good;
3563     };
3564
3565     static const ParseTestData parseTestDates[] =
3566     {
3567         { "Sat, 18 Dec 1999 00:46:40 +0100", { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, TRUE },
3568         { "Wed, 1 Dec 1999 05:17:20 +0300",  {  1, wxDateTime::Dec, 1999, 03, 17, 20 }, TRUE },
3569     };
3570
3571     for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
3572     {
3573         const char *format = parseTestDates[n].format;
3574
3575         printf("%s => ", format);
3576
3577         wxDateTime dt;
3578         if ( dt.ParseRfc822Date(format) )
3579         {
3580             printf("%s ", dt.Format().c_str());
3581
3582             if ( parseTestDates[n].good )
3583             {
3584                 wxDateTime dtReal = parseTestDates[n].date.DT();
3585                 if ( dt == dtReal )
3586                 {
3587                     puts("(ok)");
3588                 }
3589                 else
3590                 {
3591                     printf("(ERROR: should be %s)\n", dtReal.Format().c_str());
3592                 }
3593             }
3594             else
3595             {
3596                 puts("(ERROR: bad format)");
3597             }
3598         }
3599         else
3600         {
3601             printf("bad format (%s)\n",
3602                    parseTestDates[n].good ? "ERROR" : "ok");
3603         }
3604     }
3605 }
3606
3607 static void TestDateTimeInteractive()
3608 {
3609     puts("\n*** interactive wxDateTime tests ***");
3610
3611     char buf[128];
3612
3613     for ( ;; )
3614     {
3615         printf("Enter a date: ");
3616         if ( !fgets(buf, WXSIZEOF(buf), stdin) )
3617             break;
3618
3619         // kill the last '\n'
3620         buf[strlen(buf) - 1] = 0;
3621
3622         wxDateTime dt;
3623         const char *p = dt.ParseDate(buf);
3624         if ( !p )
3625         {
3626             printf("ERROR: failed to parse the date '%s'.\n", buf);
3627
3628             continue;
3629         }
3630         else if ( *p )
3631         {
3632             printf("WARNING: parsed only first %u characters.\n", p - buf);
3633         }
3634
3635         printf("%s: day %u, week of month %u/%u, week of year %u\n",
3636                dt.Format("%b %d, %Y").c_str(),
3637                dt.GetDayOfYear(),
3638                dt.GetWeekOfMonth(wxDateTime::Monday_First),
3639                dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3640                dt.GetWeekOfYear(wxDateTime::Monday_First));
3641     }
3642
3643     puts("\n*** done ***");
3644 }
3645
3646 static void TestTimeMS()
3647 {
3648     puts("*** testing millisecond-resolution support in wxDateTime ***");
3649
3650     wxDateTime dt1 = wxDateTime::Now(),
3651                dt2 = wxDateTime::UNow();
3652
3653     printf("Now = %s\n", dt1.Format("%H:%M:%S:%l").c_str());
3654     printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());
3655     printf("Dummy loop: ");
3656     for ( int i = 0; i < 6000; i++ )
3657     {
3658         //for ( int j = 0; j < 10; j++ )
3659         {
3660             wxString s;
3661             s.Printf("%g", sqrt(i));
3662         }
3663
3664         if ( !(i % 100) )
3665             putchar('.');
3666     }
3667     puts(", done");
3668
3669     dt1 = dt2;
3670     dt2 = wxDateTime::UNow();
3671     printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());
3672
3673     printf("Loop executed in %s ms\n", (dt2 - dt1).Format("%l").c_str());
3674
3675     puts("\n*** done ***");
3676 }
3677
3678 static void TestTimeArithmetics()
3679 {
3680     puts("\n*** testing arithmetic operations on wxDateTime ***");
3681
3682     static const struct ArithmData
3683     {
3684         ArithmData(const wxDateSpan& sp, const char *nam)
3685             : span(sp), name(nam) { }
3686
3687         wxDateSpan span;
3688         const char *name;
3689     } testArithmData[] =
3690     {
3691         ArithmData(wxDateSpan::Day(), "day"),
3692         ArithmData(wxDateSpan::Week(), "week"),
3693         ArithmData(wxDateSpan::Month(), "month"),
3694         ArithmData(wxDateSpan::Year(), "year"),
3695         ArithmData(wxDateSpan(1, 2, 3, 4), "year, 2 months, 3 weeks, 4 days"),
3696     };
3697
3698     wxDateTime dt(29, wxDateTime::Dec, 1999), dt1, dt2;
3699
3700     for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
3701     {
3702         wxDateSpan span = testArithmData[n].span;
3703         dt1 = dt + span;
3704         dt2 = dt - span;
3705
3706         const char *name = testArithmData[n].name;
3707         printf("%s + %s = %s, %s - %s = %s\n",
3708                dt.FormatISODate().c_str(), name, dt1.FormatISODate().c_str(),
3709                dt.FormatISODate().c_str(), name, dt2.FormatISODate().c_str());
3710
3711         printf("Going back: %s", (dt1 - span).FormatISODate().c_str());
3712         if ( dt1 - span == dt )
3713         {
3714             puts(" (ok)");
3715         }
3716         else
3717         {
3718             printf(" (ERROR: should be %s)\n", dt.FormatISODate().c_str());
3719         }
3720
3721         printf("Going forward: %s", (dt2 + span).FormatISODate().c_str());
3722         if ( dt2 + span == dt )
3723         {
3724             puts(" (ok)");
3725         }
3726         else
3727         {
3728             printf(" (ERROR: should be %s)\n", dt.FormatISODate().c_str());
3729         }
3730
3731         printf("Double increment: %s", (dt2 + 2*span).FormatISODate().c_str());
3732         if ( dt2 + 2*span == dt1 )
3733         {
3734             puts(" (ok)");
3735         }
3736         else
3737         {
3738             printf(" (ERROR: should be %s)\n", dt2.FormatISODate().c_str());
3739         }
3740
3741         puts("");
3742     }
3743 }
3744
3745 static void TestTimeHolidays()
3746 {
3747     puts("\n*** testing wxDateTimeHolidayAuthority ***\n");
3748
3749     wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3750     wxDateTime dtStart(1, tm.mon, tm.year),
3751                dtEnd = dtStart.GetLastMonthDay();
3752
3753     wxDateTimeArray hol;
3754     wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3755
3756     const wxChar *format = "%d-%b-%Y (%a)";
3757
3758     printf("All holidays between %s and %s:\n",
3759            dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3760
3761     size_t count = hol.GetCount();
3762     for ( size_t n = 0; n < count; n++ )
3763     {
3764         printf("\t%s\n", hol[n].Format(format).c_str());
3765     }
3766
3767     puts("");
3768 }
3769
3770 static void TestTimeZoneBug()
3771 {
3772     puts("\n*** testing for DST/timezone bug ***\n");
3773
3774     wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3775     for ( int i = 0; i < 31; i++ )
3776     {
3777         printf("Date %s: week day %s.\n",
3778                date.Format(_T("%d-%m-%Y")).c_str(),
3779                date.GetWeekDayName(date.GetWeekDay()).c_str());
3780
3781         date += wxDateSpan::Day();
3782     }
3783
3784     puts("");
3785 }
3786
3787 static void TestTimeSpanFormat()
3788 {
3789     puts("\n*** wxTimeSpan tests ***");
3790
3791     static const char *formats[] =
3792     {
3793         _T("(default) %H:%M:%S"),
3794         _T("%E weeks and %D days"),
3795         _T("%l milliseconds"),
3796         _T("(with ms) %H:%M:%S:%l"),
3797         _T("100%% of minutes is %M"),       // test "%%"
3798         _T("%D days and %H hours"),
3799     };
3800
3801     wxTimeSpan ts1(1, 2, 3, 4),
3802                 ts2(111, 222, 333);
3803     for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3804     {
3805         printf("ts1 = %s\tts2 = %s\n",
3806                ts1.Format(formats[n]).c_str(),
3807                ts2.Format(formats[n]).c_str());
3808     }
3809
3810     puts("");
3811 }
3812
3813 #if 0
3814
3815 // test compatibility with the old wxDate/wxTime classes
3816 static void TestTimeCompatibility()
3817 {
3818     puts("\n*** wxDateTime compatibility test ***");
3819
3820     printf("wxDate for JDN 0: %s\n", wxDate(0l).FormatDate().c_str());
3821     printf("wxDate for MJD 0: %s\n", wxDate(2400000).FormatDate().c_str());
3822
3823     double jdnNow = wxDateTime::Now().GetJDN();
3824     long jdnMidnight = (long)(jdnNow - 0.5);
3825     printf("wxDate for today: %s\n", wxDate(jdnMidnight).FormatDate().c_str());
3826
3827     jdnMidnight = wxDate().Set().GetJulianDate();
3828     printf("wxDateTime for today: %s\n",
3829             wxDateTime((double)(jdnMidnight + 0.5)).Format("%c", wxDateTime::GMT0).c_str());
3830
3831     int flags = wxEUROPEAN;//wxFULL;
3832     wxDate date;
3833     date.Set();
3834     printf("Today is %s\n", date.FormatDate(flags).c_str());
3835     for ( int n = 0; n < 7; n++ )
3836     {
3837         printf("Previous %s is %s\n",
3838                wxDateTime::GetWeekDayName((wxDateTime::WeekDay)n),
3839                date.Previous(n + 1).FormatDate(flags).c_str());
3840     }
3841 }
3842
3843 #endif // 0
3844
3845 #endif // TEST_DATETIME
3846
3847 // ----------------------------------------------------------------------------
3848 // threads
3849 // ----------------------------------------------------------------------------
3850
3851 #ifdef TEST_THREADS
3852
3853 #include <wx/thread.h>
3854
3855 static size_t gs_counter = (size_t)-1;
3856 static wxCriticalSection gs_critsect;
3857 static wxCondition gs_cond;
3858
3859 class MyJoinableThread : public wxThread
3860 {
3861 public:
3862     MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3863         { m_n = n; Create(); }
3864
3865     // thread execution starts here
3866     virtual ExitCode Entry();
3867
3868 private:
3869     size_t m_n;
3870 };
3871
3872 wxThread::ExitCode MyJoinableThread::Entry()
3873 {
3874     unsigned long res = 1;
3875     for ( size_t n = 1; n < m_n; n++ )
3876     {
3877         res *= n;
3878
3879         // it's a loooong calculation :-)
3880         Sleep(100);
3881     }
3882
3883     return (ExitCode)res;
3884 }
3885
3886 class MyDetachedThread : public wxThread
3887 {
3888 public:
3889     MyDetachedThread(size_t n, char ch)
3890     {
3891         m_n = n;
3892         m_ch = ch;
3893         m_cancelled = FALSE;
3894
3895         Create();
3896     }
3897
3898     // thread execution starts here
3899     virtual ExitCode Entry();
3900
3901     // and stops here
3902     virtual void OnExit();
3903
3904 private:
3905     size_t m_n; // number of characters to write
3906     char m_ch;  // character to write
3907
3908     bool m_cancelled;   // FALSE if we exit normally
3909 };
3910
3911 wxThread::ExitCode MyDetachedThread::Entry()
3912 {
3913     {
3914         wxCriticalSectionLocker lock(gs_critsect);
3915         if ( gs_counter == (size_t)-1 )
3916             gs_counter = 1;
3917         else
3918             gs_counter++;
3919     }
3920
3921     for ( size_t n = 0; n < m_n; n++ )
3922     {
3923         if ( TestDestroy() )
3924         {
3925             m_cancelled = TRUE;
3926
3927             break;
3928         }
3929
3930         putchar(m_ch);
3931         fflush(stdout);
3932
3933         wxThread::Sleep(100);
3934     }
3935
3936     return 0;
3937 }
3938
3939 void MyDetachedThread::OnExit()
3940 {
3941     wxLogTrace("thread", "Thread %ld is in OnExit", GetId());
3942
3943     wxCriticalSectionLocker lock(gs_critsect);
3944     if ( !--gs_counter && !m_cancelled )
3945         gs_cond.Signal();
3946 }
3947
3948 void TestDetachedThreads()
3949 {
3950     puts("\n*** Testing detached threads ***");
3951
3952     static const size_t nThreads = 3;
3953     MyDetachedThread *threads[nThreads];
3954     size_t n;
3955     for ( n = 0; n < nThreads; n++ )
3956     {
3957         threads[n] = new MyDetachedThread(10, 'A' + n);
3958     }
3959
3960     threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
3961     threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
3962
3963     for ( n = 0; n < nThreads; n++ )
3964     {
3965         threads[n]->Run();
3966     }
3967
3968     // wait until all threads terminate
3969     gs_cond.Wait();
3970
3971     puts("");
3972 }
3973
3974 void TestJoinableThreads()
3975 {
3976     puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
3977
3978     // calc 10! in the background
3979     MyJoinableThread thread(10);
3980     thread.Run();
3981
3982     printf("\nThread terminated with exit code %lu.\n",
3983            (unsigned long)thread.Wait());
3984 }
3985
3986 void TestThreadSuspend()
3987 {
3988     puts("\n*** Testing thread suspend/resume functions ***");
3989
3990     MyDetachedThread *thread = new MyDetachedThread(15, 'X');
3991
3992     thread->Run();
3993
3994     // this is for this demo only, in a real life program we'd use another
3995     // condition variable which would be signaled from wxThread::Entry() to
3996     // tell us that the thread really started running - but here just wait a
3997     // bit and hope that it will be enough (the problem is, of course, that
3998     // the thread might still not run when we call Pause() which will result
3999     // in an error)
4000     wxThread::Sleep(300);
4001
4002     for ( size_t n = 0; n < 3; n++ )
4003     {
4004         thread->Pause();
4005
4006         puts("\nThread suspended");
4007         if ( n > 0 )
4008         {
4009             // don't sleep but resume immediately the first time
4010             wxThread::Sleep(300);
4011         }
4012         puts("Going to resume the thread");
4013
4014         thread->Resume();
4015     }
4016
4017     puts("Waiting until it terminates now");
4018
4019     // wait until the thread terminates
4020     gs_cond.Wait();
4021
4022     puts("");
4023 }
4024
4025 void TestThreadDelete()
4026 {
4027     // As above, using Sleep() is only for testing here - we must use some
4028     // synchronisation object instead to ensure that the thread is still
4029     // running when we delete it - deleting a detached thread which already
4030     // terminated will lead to a crash!
4031
4032     puts("\n*** Testing thread delete function ***");
4033
4034     MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
4035
4036     thread0->Delete();
4037
4038     puts("\nDeleted a thread which didn't start to run yet.");
4039
4040     MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
4041
4042     thread1->Run();
4043
4044     wxThread::Sleep(300);
4045
4046     thread1->Delete();
4047
4048     puts("\nDeleted a running thread.");
4049
4050     MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
4051
4052     thread2->Run();
4053
4054     wxThread::Sleep(300);
4055
4056     thread2->Pause();
4057
4058     thread2->Delete();
4059
4060     puts("\nDeleted a sleeping thread.");
4061
4062     MyJoinableThread thread3(20);
4063     thread3.Run();
4064
4065     thread3.Delete();
4066
4067     puts("\nDeleted a joinable thread.");
4068
4069     MyJoinableThread thread4(2);
4070     thread4.Run();
4071
4072     wxThread::Sleep(300);
4073
4074     thread4.Delete();
4075
4076     puts("\nDeleted a joinable thread which already terminated.");
4077
4078     puts("");
4079 }
4080
4081 #endif // TEST_THREADS
4082
4083 // ----------------------------------------------------------------------------
4084 // arrays
4085 // ----------------------------------------------------------------------------
4086
4087 #ifdef TEST_ARRAYS
4088
4089 static void PrintArray(const char* name, const wxArrayString& array)
4090 {
4091     printf("Dump of the array '%s'\n", name);
4092
4093     size_t nCount = array.GetCount();
4094     for ( size_t n = 0; n < nCount; n++ )
4095     {
4096         printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
4097     }
4098 }
4099
4100 static void PrintArray(const char* name, const wxArrayInt& array)
4101 {
4102     printf("Dump of the array '%s'\n", name);
4103
4104     size_t nCount = array.GetCount();
4105     for ( size_t n = 0; n < nCount; n++ )
4106     {
4107         printf("\t%s[%u] = %d\n", name, n, array[n]);
4108     }
4109 }
4110
4111 int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
4112                                     const wxString& second)
4113 {
4114     return first.length() - second.length();
4115 }
4116
4117 int wxCMPFUNC_CONV IntCompare(int *first,
4118                               int *second)
4119 {
4120     return *first - *second;
4121 }
4122
4123 int wxCMPFUNC_CONV IntRevCompare(int *first,
4124                               int *second)
4125 {
4126     return *second - *first;
4127 }
4128
4129 static void TestArrayOfInts()
4130 {
4131     puts("*** Testing wxArrayInt ***\n");
4132
4133     wxArrayInt a;
4134     a.Add(1);
4135     a.Add(17);
4136     a.Add(5);
4137     a.Add(3);
4138
4139     puts("Initially:");
4140     PrintArray("a", a);
4141
4142     puts("After sort:");
4143     a.Sort(IntCompare);
4144     PrintArray("a", a);
4145
4146     puts("After reverse sort:");
4147     a.Sort(IntRevCompare);
4148     PrintArray("a", a);
4149 }
4150
4151 #include "wx/dynarray.h"
4152
4153 WX_DECLARE_OBJARRAY(Bar, ArrayBars);
4154 #include "wx/arrimpl.cpp"
4155 WX_DEFINE_OBJARRAY(ArrayBars);
4156
4157 static void TestArrayOfObjects()
4158 {
4159     puts("*** Testing wxObjArray ***\n");
4160
4161     {
4162         ArrayBars bars;
4163         Bar bar("second bar");
4164
4165         printf("Initially: %u objects in the array, %u objects total.\n",
4166                bars.GetCount(), Bar::GetNumber());
4167
4168         bars.Add(new Bar("first bar"));
4169         bars.Add(bar);
4170
4171         printf("Now: %u objects in the array, %u objects total.\n",
4172                bars.GetCount(), Bar::GetNumber());
4173
4174         bars.Empty();
4175
4176         printf("After Empty(): %u objects in the array, %u objects total.\n",
4177                bars.GetCount(), Bar::GetNumber());
4178     }
4179
4180     printf("Finally: no more objects in the array, %u objects total.\n",
4181            Bar::GetNumber());
4182 }
4183
4184 #endif // TEST_ARRAYS
4185
4186 // ----------------------------------------------------------------------------
4187 // strings
4188 // ----------------------------------------------------------------------------
4189
4190 #ifdef TEST_STRINGS
4191
4192 #include "wx/timer.h"
4193 #include "wx/tokenzr.h"
4194
4195 static void TestStringConstruction()
4196 {
4197     puts("*** Testing wxString constructores ***");
4198
4199     #define TEST_CTOR(args, res)                                               \
4200         {                                                                      \
4201             wxString s args ;                                                  \
4202             printf("wxString%s = %s ", #args, s.c_str());                      \
4203             if ( s == res )                                                    \
4204             {                                                                  \
4205                 puts("(ok)");                                                  \
4206             }                                                                  \
4207             else                                                               \
4208             {                                                                  \
4209                 printf("(ERROR: should be %s)\n", res);                        \
4210             }                                                                  \
4211         }
4212
4213     TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
4214     TEST_CTOR((_T("Hello"), 4), _T("Hell"));
4215     TEST_CTOR((_T("Hello"), 5), _T("Hello"));
4216     // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
4217
4218     static const wxChar *s = _T("?really!");
4219     const wxChar *start = wxStrchr(s, _T('r'));
4220     const wxChar *end = wxStrchr(s, _T('!'));
4221     TEST_CTOR((start, end), _T("really"));
4222
4223     puts("");
4224 }
4225
4226 static void TestString()
4227 {
4228     wxStopWatch sw;
4229
4230     wxString a, b, c;
4231
4232     a.reserve (128);
4233     b.reserve (128);
4234     c.reserve (128);
4235
4236     for (int i = 0; i < 1000000; ++i)
4237     {
4238         a = "Hello";
4239         b = " world";
4240         c = "! How'ya doin'?";
4241         a += b;
4242         a += c;
4243         c = "Hello world! What's up?";
4244         if (c != a)
4245             c = "Doh!";
4246     }
4247
4248     printf ("TestString elapsed time: %ld\n", sw.Time());
4249 }
4250
4251 static void TestPChar()
4252 {
4253     wxStopWatch sw;
4254
4255     char a [128];
4256     char b [128];
4257     char c [128];
4258
4259     for (int i = 0; i < 1000000; ++i)
4260     {
4261         strcpy (a, "Hello");
4262         strcpy (b, " world");
4263         strcpy (c, "! How'ya doin'?");
4264         strcat (a, b);
4265         strcat (a, c);
4266         strcpy (c, "Hello world! What's up?");
4267         if (strcmp (c, a) == 0)
4268             strcpy (c, "Doh!");
4269     }
4270
4271     printf ("TestPChar elapsed time: %ld\n", sw.Time());
4272 }
4273
4274 static void TestStringSub()
4275 {
4276     wxString s("Hello, world!");
4277
4278     puts("*** Testing wxString substring extraction ***");
4279
4280     printf("String = '%s'\n", s.c_str());
4281     printf("Left(5) = '%s'\n", s.Left(5).c_str());
4282     printf("Right(6) = '%s'\n", s.Right(6).c_str());
4283     printf("Mid(3, 5) = '%s'\n", s(3, 5).c_str());
4284     printf("Mid(3) = '%s'\n", s.Mid(3).c_str());
4285     printf("substr(3, 5) = '%s'\n", s.substr(3, 5).c_str());
4286     printf("substr(3) = '%s'\n", s.substr(3).c_str());
4287
4288     static const wxChar *prefixes[] =
4289     {
4290         _T("Hello"),
4291         _T("Hello, "),
4292         _T("Hello, world!"),
4293         _T("Hello, world!!!"),
4294         _T(""),
4295         _T("Goodbye"),
4296         _T("Hi"),
4297     };
4298
4299     for ( size_t n = 0; n < WXSIZEOF(prefixes); n++ )
4300     {
4301         wxString prefix = prefixes[n], rest;
4302         bool rc = s.StartsWith(prefix, &rest);
4303         printf("StartsWith('%s') = %s", prefix.c_str(), rc ? "TRUE" : "FALSE");
4304         if ( rc )
4305         {
4306             printf(" (the rest is '%s')\n", rest.c_str());
4307         }
4308         else
4309         {
4310             putchar('\n');
4311         }
4312     }
4313
4314     puts("");
4315 }
4316
4317 static void TestStringFormat()
4318 {
4319     puts("*** Testing wxString formatting ***");
4320
4321     wxString s;
4322     s.Printf("%03d", 18);
4323
4324     printf("Number 18: %s\n", wxString::Format("%03d", 18).c_str());
4325     printf("Number 18: %s\n", s.c_str());
4326
4327     puts("");
4328 }
4329
4330 // returns "not found" for npos, value for all others
4331 static wxString PosToString(size_t res)
4332 {
4333     wxString s = res == wxString::npos ? wxString(_T("not found"))
4334                                        : wxString::Format(_T("%u"), res);
4335     return s;
4336 }
4337
4338 static void TestStringFind()
4339 {
4340     puts("*** Testing wxString find() functions ***");
4341
4342     static const wxChar *strToFind = _T("ell");
4343     static const struct StringFindTest
4344     {
4345         const wxChar *str;
4346         size_t        start,
4347                       result;   // of searching "ell" in str
4348     } findTestData[] =
4349     {
4350         { _T("Well, hello world"),  0, 1 },
4351         { _T("Well, hello world"),  6, 7 },
4352         { _T("Well, hello world"),  9, wxString::npos },
4353     };
4354
4355     for ( size_t n = 0; n < WXSIZEOF(findTestData); n++ )
4356     {
4357         const StringFindTest& ft = findTestData[n];
4358         size_t res = wxString(ft.str).find(strToFind, ft.start);
4359
4360         printf(_T("Index of '%s' in '%s' starting from %u is %s "),
4361                strToFind, ft.str, ft.start, PosToString(res).c_str());
4362
4363         size_t resTrue = ft.result;
4364         if ( res == resTrue )
4365         {
4366             puts(_T("(ok)"));
4367         }
4368         else
4369         {
4370             printf(_T("(ERROR: should be %s)\n"),
4371                    PosToString(resTrue).c_str());
4372         }
4373     }
4374
4375     puts("");
4376 }
4377
4378 static void TestStringTokenizer()
4379 {
4380     puts("*** Testing wxStringTokenizer ***");
4381
4382     static const wxChar *modeNames[] =
4383     {
4384         _T("default"),
4385         _T("return empty"),
4386         _T("return all empty"),
4387         _T("with delims"),
4388         _T("like strtok"),
4389     };
4390
4391     static const struct StringTokenizerTest
4392     {
4393         const wxChar *str;              // string to tokenize
4394         const wxChar *delims;           // delimiters to use
4395         size_t        count;            // count of token
4396         wxStringTokenizerMode mode;     // how should we tokenize it
4397     } tokenizerTestData[] =
4398     {
4399         { _T(""), _T(" "), 0 },
4400         { _T("Hello, world"), _T(" "), 2 },
4401         { _T("Hello,   world  "), _T(" "), 2 },
4402         { _T("Hello, world"), _T(","), 2 },
4403         { _T("Hello, world!"), _T(",!"), 2 },
4404         { _T("Hello,, world!"), _T(",!"), 3 },
4405         { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL },
4406         { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
4407         { _T("1 \t3\t4  6   "), wxDEFAULT_DELIMITERS, 4 },
4408         { _T("1 \t3\t4  6   "), wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY },
4409         { _T("1 \t3\t4  6   "), wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL },
4410         { _T("01/02/99"), _T("/-"), 3 },
4411         { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS },
4412     };
4413
4414     for ( size_t n = 0; n < WXSIZEOF(tokenizerTestData); n++ )
4415     {
4416         const StringTokenizerTest& tt = tokenizerTestData[n];
4417         wxStringTokenizer tkz(tt.str, tt.delims, tt.mode);
4418
4419         size_t count = tkz.CountTokens();
4420         printf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
4421                MakePrintable(tt.str).c_str(),
4422                count,
4423                MakePrintable(tt.delims).c_str(),
4424                modeNames[tkz.GetMode()]);
4425         if ( count == tt.count )
4426         {
4427             puts(_T("(ok)"));
4428         }
4429         else
4430         {
4431             printf(_T("(ERROR: should be %u)\n"), tt.count);
4432
4433             continue;
4434         }
4435
4436         // if we emulate strtok(), check that we do it correctly
4437         wxChar *buf, *s = NULL, *last;
4438
4439         if ( tkz.GetMode() == wxTOKEN_STRTOK )
4440         {
4441             buf = new wxChar[wxStrlen(tt.str) + 1];
4442             wxStrcpy(buf, tt.str);
4443
4444             s = wxStrtok(buf, tt.delims, &last);
4445         }
4446         else
4447         {
4448             buf = NULL;
4449         }
4450
4451         // now show the tokens themselves
4452         size_t count2 = 0;
4453         while ( tkz.HasMoreTokens() )
4454         {
4455             wxString token = tkz.GetNextToken();
4456
4457             printf(_T("\ttoken %u: '%s'"),
4458                    ++count2,
4459                    MakePrintable(token).c_str());
4460
4461             if ( buf )
4462             {
4463                 if ( token == s )
4464                 {
4465                     puts(" (ok)");
4466                 }
4467                 else
4468                 {
4469                     printf(" (ERROR: should be %s)\n", s);
4470                 }
4471
4472                 s = wxStrtok(NULL, tt.delims, &last);
4473             }
4474             else
4475             {
4476                 // nothing to compare with
4477                 puts("");
4478             }
4479         }
4480
4481         if ( count2 != count )
4482         {
4483             puts(_T("\tERROR: token count mismatch"));
4484         }
4485
4486         delete [] buf;
4487     }
4488
4489     puts("");
4490 }
4491
4492 static void TestStringReplace()
4493 {
4494     puts("*** Testing wxString::replace ***");
4495
4496     static const struct StringReplaceTestData
4497     {
4498         const wxChar *original;     // original test string
4499         size_t start, len;          // the part to replace
4500         const wxChar *replacement;  // the replacement string
4501         const wxChar *result;       // and the expected result
4502     } stringReplaceTestData[] =
4503     {
4504         { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
4505         { _T("increase"), 0, 2, _T("de"), _T("decrease") },
4506         { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
4507         { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
4508         { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
4509     };
4510
4511     for ( size_t n = 0; n < WXSIZEOF(stringReplaceTestData); n++ )
4512     {
4513         const StringReplaceTestData data = stringReplaceTestData[n];
4514
4515         wxString original = data.original;
4516         original.replace(data.start, data.len, data.replacement);
4517
4518         wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
4519                  data.original, data.start, data.len, data.replacement,
4520                  original.c_str());
4521
4522         if ( original == data.result )
4523         {
4524             puts("(ok)");
4525         }
4526         else
4527         {
4528             wxPrintf(_T("(ERROR: should be '%s')\n"), data.result);
4529         }
4530     }
4531
4532     puts("");
4533 }
4534
4535 #endif // TEST_STRINGS
4536
4537 // ----------------------------------------------------------------------------
4538 // entry point
4539 // ----------------------------------------------------------------------------
4540
4541 int main(int argc, char **argv)
4542 {
4543     if ( !wxInitialize() )
4544     {
4545         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
4546     }
4547
4548 #ifdef TEST_CHARSET
4549     TestCharset();
4550 #endif // TEST_CHARSET
4551
4552 #ifdef TEST_CMDLINE
4553     static const wxCmdLineEntryDesc cmdLineDesc[] =
4554     {
4555         { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
4556         { wxCMD_LINE_SWITCH, "q", "quiet",   "be quiet" },
4557
4558         { wxCMD_LINE_OPTION, "o", "output",  "output file" },
4559         { wxCMD_LINE_OPTION, "i", "input",   "input dir" },
4560         { wxCMD_LINE_OPTION, "s", "size",    "output block size", wxCMD_LINE_VAL_NUMBER },
4561         { wxCMD_LINE_OPTION, "d", "date",    "output file date", wxCMD_LINE_VAL_DATE },
4562
4563         { wxCMD_LINE_PARAM,  NULL, NULL, "input file",
4564             wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
4565
4566         { wxCMD_LINE_NONE }
4567     };
4568
4569     wxCmdLineParser parser(cmdLineDesc, argc, argv);
4570
4571     parser.AddOption("project_name", "", "full path to project file",
4572                      wxCMD_LINE_VAL_STRING,
4573                      wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
4574
4575     switch ( parser.Parse() )
4576     {
4577         case -1:
4578             wxLogMessage("Help was given, terminating.");
4579             break;
4580
4581         case 0:
4582             ShowCmdLine(parser);
4583             break;
4584
4585         default:
4586             wxLogMessage("Syntax error detected, aborting.");
4587             break;
4588     }
4589 #endif // TEST_CMDLINE
4590
4591 #ifdef TEST_STRINGS
4592     if ( 0 )
4593     {
4594         TestPChar();
4595         TestString();
4596     }
4597         TestStringSub();
4598     if ( 0 )
4599     {
4600         TestStringConstruction();
4601         TestStringFormat();
4602         TestStringFind();
4603         TestStringTokenizer();
4604         TestStringReplace();
4605     }
4606 #endif // TEST_STRINGS
4607
4608 #ifdef TEST_ARRAYS
4609     if ( 0 )
4610     {
4611     wxArrayString a1;
4612     a1.Add("tiger");
4613     a1.Add("cat");
4614     a1.Add("lion");
4615     a1.Add("dog");
4616     a1.Add("human");
4617     a1.Add("ape");
4618
4619     puts("*** Initially:");
4620
4621     PrintArray("a1", a1);
4622
4623     wxArrayString a2(a1);
4624     PrintArray("a2", a2);
4625
4626     wxSortedArrayString a3(a1);
4627     PrintArray("a3", a3);
4628
4629     puts("*** After deleting a string from a1");
4630     a1.Remove(2);
4631
4632     PrintArray("a1", a1);
4633     PrintArray("a2", a2);
4634     PrintArray("a3", a3);
4635
4636     puts("*** After reassigning a1 to a2 and a3");
4637     a3 = a2 = a1;
4638     PrintArray("a2", a2);
4639     PrintArray("a3", a3);
4640
4641     puts("*** After sorting a1");
4642     a1.Sort();
4643     PrintArray("a1", a1);
4644
4645     puts("*** After sorting a1 in reverse order");
4646     a1.Sort(TRUE);
4647     PrintArray("a1", a1);
4648
4649     puts("*** After sorting a1 by the string length");
4650     a1.Sort(StringLenCompare);
4651     PrintArray("a1", a1);
4652
4653     TestArrayOfObjects();
4654     }
4655     TestArrayOfInts();
4656 #endif // TEST_ARRAYS
4657
4658 #ifdef TEST_DIR
4659     if ( 0 )
4660         TestDirEnum();
4661     TestDirTraverse();
4662 #endif // TEST_DIR
4663
4664 #ifdef TEST_DLLLOADER
4665     TestDllLoad();
4666 #endif // TEST_DLLLOADER
4667
4668 #ifdef TEST_ENVIRON
4669     TestEnvironment();
4670 #endif // TEST_ENVIRON
4671
4672 #ifdef TEST_EXECUTE
4673     TestExecute();
4674 #endif // TEST_EXECUTE
4675
4676 #ifdef TEST_FILECONF
4677     TestFileConfRead();
4678 #endif // TEST_FILECONF
4679
4680 #ifdef TEST_LIST
4681     TestListCtor();
4682 #endif // TEST_LIST
4683
4684 #ifdef TEST_LOCALE
4685     TestDefaultLang();
4686 #endif // TEST_LOCALE
4687
4688 #ifdef TEST_LOG
4689     wxString s;
4690     for ( size_t n = 0; n < 8000; n++ )
4691     {
4692         s << (char)('A' + (n % 26));
4693     }
4694
4695     wxString msg;
4696     msg.Printf("A very very long message: '%s', the end!\n", s.c_str());
4697
4698     // this one shouldn't be truncated
4699     printf(msg);
4700
4701     // but this one will because log functions use fixed size buffer
4702     // (note that it doesn't need '\n' at the end neither - will be added
4703     //  by wxLog anyhow)
4704     wxLogMessage("A very very long message 2: '%s', the end!", s.c_str());
4705 #endif // TEST_LOG
4706
4707 #ifdef TEST_FILE
4708     if ( 0 )
4709     {
4710         TestFileRead();
4711         TestTextFileRead();
4712     }
4713     TestFileCopy();
4714 #endif // TEST_FILE
4715
4716 #ifdef TEST_FILENAME
4717     TestFileNameSplit();
4718     if ( 0 )
4719     {
4720         TestFileNameConstruction();
4721         TestFileNameCwd();
4722         TestFileNameComparison();
4723         TestFileNameOperations();
4724     }
4725 #endif // TEST_FILENAME
4726
4727 #ifdef TEST_THREADS
4728     int nCPUs = wxThread::GetCPUCount();
4729     printf("This system has %d CPUs\n", nCPUs);
4730     if ( nCPUs != -1 )
4731         wxThread::SetConcurrency(nCPUs);
4732
4733     if ( argc > 1 && argv[1][0] == 't' )
4734         wxLog::AddTraceMask("thread");
4735
4736     if ( 1 )
4737         TestDetachedThreads();
4738     if ( 1 )
4739         TestJoinableThreads();
4740     if ( 1 )
4741         TestThreadSuspend();
4742     if ( 1 )
4743         TestThreadDelete();
4744
4745 #endif // TEST_THREADS
4746
4747 #ifdef TEST_LONGLONG
4748     // seed pseudo random generator
4749     srand((unsigned)time(NULL));
4750
4751     if ( 0 )
4752     {
4753         TestSpeed();
4754     }
4755     if ( 0 )
4756     {
4757         TestMultiplication();
4758         TestDivision();
4759         TestAddition();
4760         TestLongLongConversion();
4761         TestBitOperations();
4762     }
4763     TestLongLongComparison();
4764 #endif // TEST_LONGLONG
4765
4766 #ifdef TEST_HASH
4767     TestHash();
4768 #endif // TEST_HASH
4769
4770 #ifdef TEST_MIME
4771     wxLog::AddTraceMask(_T("mime"));
4772     if ( 1 )
4773     {
4774         TestMimeEnum();
4775         TestMimeOverride();
4776         TestMimeFilename();
4777     }
4778     else
4779         TestMimeAssociate();
4780 #endif // TEST_MIME
4781
4782 #ifdef TEST_INFO_FUNCTIONS
4783     TestOsInfo();
4784     TestUserInfo();
4785 #endif // TEST_INFO_FUNCTIONS
4786
4787 #ifdef TEST_PATHLIST
4788     TestPathList();
4789 #endif // TEST_PATHLIST
4790
4791 #ifdef TEST_REGCONF
4792     TestRegConfWrite();
4793 #endif // TEST_REGCONF
4794
4795 #ifdef TEST_REGISTRY
4796     if ( 0 )
4797         TestRegistryRead();
4798     TestRegistryAssociation();
4799 #endif // TEST_REGISTRY
4800
4801 #ifdef TEST_SOCKETS
4802     if ( 0 )
4803     {
4804         TestSocketServer();
4805     }
4806         TestSocketClient();
4807 #endif // TEST_SOCKETS
4808
4809 #ifdef TEST_FTP
4810     wxLog::AddTraceMask(FTP_TRACE_MASK);
4811     if ( TestFtpConnect() )
4812     {
4813             TestFtpFileSize();
4814         if ( 0 )
4815         {
4816             TestFtpList();
4817             TestFtpDownload();
4818             TestFtpMisc();
4819             TestFtpUpload();
4820         }
4821         if ( 0 )
4822         TestFtpInteractive();
4823     }
4824     //else: connecting to the FTP server failed
4825
4826     if ( 0 )
4827         TestFtpWuFtpd();
4828 #endif // TEST_FTP
4829
4830 #ifdef TEST_STREAMS
4831     if ( 0 )
4832     TestFileStream();
4833     TestMemoryStream();
4834 #endif // TEST_STREAMS
4835
4836 #ifdef TEST_TIMER
4837     TestStopWatch();
4838 #endif // TEST_TIMER
4839
4840 #ifdef TEST_DATETIME
4841     if ( 0 )
4842     {
4843         TestTimeSet();
4844         TestTimeStatic();
4845         TestTimeRange();
4846         TestTimeZones();
4847         TestTimeTicks();
4848         TestTimeJDN();
4849         TestTimeDST();
4850         TestTimeWDays();
4851         TestTimeWNumber();
4852         TestTimeParse();
4853         TestTimeArithmetics();
4854         TestTimeHolidays();
4855         TestTimeFormat();
4856         TestTimeMS();
4857
4858         TestTimeZoneBug();
4859     }
4860     TestTimeSpanFormat();
4861     if ( 0 )
4862         TestDateTimeInteractive();
4863 #endif // TEST_DATETIME
4864
4865 #ifdef TEST_USLEEP
4866     puts("Sleeping for 3 seconds... z-z-z-z-z...");
4867     wxUsleep(3000);
4868 #endif // TEST_USLEEP
4869
4870 #ifdef TEST_VCARD
4871     if ( 0 )
4872     TestVCardRead();
4873     TestVCardWrite();
4874 #endif // TEST_VCARD
4875
4876 #ifdef TEST_WCHAR
4877     TestUtf8();
4878 #endif // TEST_WCHAR
4879
4880 #ifdef TEST_ZIP
4881     if ( 0 )
4882         TestZipStreamRead();
4883     TestZipFileSystem();
4884 #endif // TEST_ZIP
4885
4886 #ifdef TEST_ZLIB
4887     if ( 0 )
4888     TestZlibStreamWrite();
4889     TestZlibStreamRead();
4890 #endif // TEST_ZLIB
4891
4892     wxUninitialize();
4893
4894     return 0;
4895 }
4896