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