samples/console/console.cpp

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