samples/console/console.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/console/console.cpp
   3 // Purpose:     A sample console (as opposed to GUI) program using wxWidgets
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04.10.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/defs.h"
  21
  22 #include <stdio.h>
  23
  24 #include "wx/string.h"
  25 #include "wx/file.h"
  26 #include "wx/filename.h"
  27 #include "wx/app.h"
  28 #include "wx/log.h"
  29 #include "wx/apptrait.h"
  30 #include "wx/platinfo.h"
  31 #include "wx/wxchar.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 wxWidgets 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)? Define TEST_ALL to 0 to do a single
  52 // test, define it to 1 to do all tests.
  53 #define TEST_ALL 0
  54
  55
  56 #if TEST_ALL
  57     #define TEST_CMDLINE
  58     #define TEST_DATETIME
  59     #define TEST_DIR
  60     #define TEST_DYNLIB
  61     #define TEST_ENVIRON
  62     #define TEST_EXECUTE
  63     #define TEST_FILE
  64     #define TEST_FILECONF
  65     #define TEST_FILENAME
  66     #define TEST_FILETIME
  67  //   #define TEST_FTP  --FIXME! (RN)
  68     #define TEST_INFO_FUNCTIONS
  69     #define TEST_LOCALE
  70     #define TEST_LOG
  71     #define TEST_MIME
  72     #define TEST_MODULE
  73     #define TEST_PATHLIST
  74     #define TEST_PRINTF
  75     #define TEST_REGCONF
  76     #define TEST_REGEX
  77     #define TEST_REGISTRY
  78     #define TEST_SCOPEGUARD
  79     #define TEST_SNGLINST
  80 //    #define TEST_SOCKETS  --FIXME! (RN)
  81     #define TEST_STACKWALKER
  82     #define TEST_STDPATHS
  83     #define TEST_STREAMS
  84     #define TEST_TEXTSTREAM
  85     #define TEST_THREADS
  86     #define TEST_TIMER
  87     // #define TEST_VCARD            -- don't enable this (VZ)
  88 //    #define TEST_VOLUME   --FIXME! (RN)
  89     #define TEST_WCHAR
  90     #define TEST_ZIP
  91 #else // #if TEST_ALL
  92     #define TEST_FTP
  93 #endif
  94
  95 // some tests are interactive, define this to run them
  96 #ifdef TEST_INTERACTIVE
  97     #undef TEST_INTERACTIVE
  98
  99     #define TEST_INTERACTIVE 1
 100 #else
 101     #define TEST_INTERACTIVE 0
 102 #endif
 103
 104 // ============================================================================
 105 // implementation
 106 // ============================================================================
 107
 108 // ----------------------------------------------------------------------------
 109 // helper functions
 110 // ----------------------------------------------------------------------------
 111
 112 #if defined(TEST_SOCKETS)
 113
 114 // replace TABs with \t and CRs with \n
 115 static wxString MakePrintable(const wxChar *s)
 116 {
 117     wxString str(s);
 118     (void)str.Replace(_T("\t"), _T("\\t"));
 119     (void)str.Replace(_T("\n"), _T("\\n"));
 120     (void)str.Replace(_T("\r"), _T("\\r"));
 121
 122     return str;
 123 }
 124
 125 #endif // MakePrintable() is used
 126
 127 // ----------------------------------------------------------------------------
 128 // wxCmdLineParser
 129 // ----------------------------------------------------------------------------
 130
 131 #ifdef TEST_CMDLINE
 132
 133 #include "wx/cmdline.h"
 134 #include "wx/datetime.h"
 135
 136 #if wxUSE_CMDLINE_PARSER
 137
 138 static void ShowCmdLine(const wxCmdLineParser& parser)
 139 {
 140     wxString s = _T("Command line parsed successfully:\nInput files: ");
 141
 142     size_t count = parser.GetParamCount();
 143     for ( size_t param = 0; param < count; param++ )
 144     {
 145         s << parser.GetParam(param) << ' ';
 146     }
 147
 148     s << '\n'
 149       << _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
 150       << _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
 151
 152     wxString strVal;
 153     long lVal;
 154     double dVal;
 155     wxDateTime dt;
 156     if ( parser.Found(_T("o"), &strVal) )
 157         s << _T("Output file:\t") << strVal << '\n';
 158     if ( parser.Found(_T("i"), &strVal) )
 159         s << _T("Input dir:\t") << strVal << '\n';
 160     if ( parser.Found(_T("s"), &lVal) )
 161         s << _T("Size:\t") << lVal << '\n';
 162     if ( parser.Found(_T("f"), &dVal) )
 163         s << _T("Double:\t") << dVal << '\n';
 164     if ( parser.Found(_T("d"), &dt) )
 165         s << _T("Date:\t") << dt.FormatISODate() << '\n';
 166     if ( parser.Found(_T("project_name"), &strVal) )
 167         s << _T("Project:\t") << strVal << '\n';
 168
 169     wxLogMessage(s);
 170 }
 171
 172 #endif // wxUSE_CMDLINE_PARSER
 173
 174 static void TestCmdLineConvert()
 175 {
 176     static const wxChar *cmdlines[] =
 177     {
 178         _T("arg1 arg2"),
 179         _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
 180         _T("literal \\\" and \"\""),
 181     };
 182
 183     for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
 184     {
 185         const wxChar *cmdline = cmdlines[n];
 186         wxPrintf(_T("Parsing: %s\n"), cmdline);
 187         wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
 188
 189         size_t count = args.GetCount();
 190         wxPrintf(_T("\targc = %u\n"), count);
 191         for ( size_t arg = 0; arg < count; arg++ )
 192         {
 193             wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
 194         }
 195     }
 196 }
 197
 198 #endif // TEST_CMDLINE
 199
 200 // ----------------------------------------------------------------------------
 201 // wxDir
 202 // ----------------------------------------------------------------------------
 203
 204 #ifdef TEST_DIR
 205
 206 #include "wx/dir.h"
 207
 208 #ifdef __UNIX__
 209     static const wxChar *ROOTDIR = _T("/");
 210     static const wxChar *TESTDIR = _T("/usr/local/share");
 211 #elif defined(__WXMSW__) || defined(__DOS__) || defined(__OS2__)
 212     static const wxChar *ROOTDIR = _T("c:\\");
 213     static const wxChar *TESTDIR = _T("d:\\");
 214 #else
 215     #error "don't know where the root directory is"
 216 #endif
 217
 218 static void TestDirEnumHelper(wxDir& dir,
 219                               int flags = wxDIR_DEFAULT,
 220                               const wxString& filespec = wxEmptyString)
 221 {
 222     wxString filename;
 223
 224     if ( !dir.IsOpened() )
 225         return;
 226
 227     bool cont = dir.GetFirst(&filename, filespec, flags);
 228     while ( cont )
 229     {
 230         wxPrintf(_T("\t%s\n"), filename.c_str());
 231
 232         cont = dir.GetNext(&filename);
 233     }
 234
 235     wxPuts(wxEmptyString);
 236 }
 237
 238 #if TEST_ALL
 239
 240 static void TestDirEnum()
 241 {
 242     wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
 243
 244     wxString cwd = wxGetCwd();
 245     if ( !wxDir::Exists(cwd) )
 246     {
 247         wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
 248         return;
 249     }
 250
 251     wxDir dir(cwd);
 252     if ( !dir.IsOpened() )
 253     {
 254         wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
 255         return;
 256     }
 257
 258     wxPuts(_T("Enumerating everything in current directory:"));
 259     TestDirEnumHelper(dir);
 260
 261     wxPuts(_T("Enumerating really everything in current directory:"));
 262     TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
 263
 264     wxPuts(_T("Enumerating object files in current directory:"));
 265     TestDirEnumHelper(dir, wxDIR_DEFAULT, _T("*.o*"));
 266
 267     wxPuts(_T("Enumerating directories in current directory:"));
 268     TestDirEnumHelper(dir, wxDIR_DIRS);
 269
 270     wxPuts(_T("Enumerating files in current directory:"));
 271     TestDirEnumHelper(dir, wxDIR_FILES);
 272
 273     wxPuts(_T("Enumerating files including hidden in current directory:"));
 274     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 275
 276     dir.Open(ROOTDIR);
 277
 278     wxPuts(_T("Enumerating everything in root directory:"));
 279     TestDirEnumHelper(dir, wxDIR_DEFAULT);
 280
 281     wxPuts(_T("Enumerating directories in root directory:"));
 282     TestDirEnumHelper(dir, wxDIR_DIRS);
 283
 284     wxPuts(_T("Enumerating files in root directory:"));
 285     TestDirEnumHelper(dir, wxDIR_FILES);
 286
 287     wxPuts(_T("Enumerating files including hidden in root directory:"));
 288     TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
 289
 290     wxPuts(_T("Enumerating files in non existing directory:"));
 291     wxDir dirNo(_T("nosuchdir"));
 292     TestDirEnumHelper(dirNo);
 293 }
 294
 295 #endif // TEST_ALL
 296
 297 class DirPrintTraverser : public wxDirTraverser
 298 {
 299 public:
 300     virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
 301     {
 302         return wxDIR_CONTINUE;
 303     }
 304
 305     virtual wxDirTraverseResult OnDir(const wxString& dirname)
 306     {
 307         wxString path, name, ext;
 308         wxFileName::SplitPath(dirname, &path, &name, &ext);
 309
 310         if ( !ext.empty() )
 311             name << _T('.') << ext;
 312
 313         wxString indent;
 314         for ( const wxChar *p = path.c_str(); *p; p++ )
 315         {
 316             if ( wxIsPathSeparator(*p) )
 317                 indent += _T("    ");
 318         }
 319
 320         wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
 321
 322         return wxDIR_CONTINUE;
 323     }
 324 };
 325
 326 static void TestDirTraverse()
 327 {
 328     wxPuts(_T("*** Testing wxDir::Traverse() ***"));
 329
 330     // enum all files
 331     wxArrayString files;
 332     size_t n = wxDir::GetAllFiles(TESTDIR, &files);
 333     wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
 334     if ( n > 1 )
 335     {
 336         wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
 337         wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
 338     }
 339
 340     // enum again with custom traverser
 341     wxPuts(_T("Now enumerating directories:"));
 342     wxDir dir(TESTDIR);
 343     DirPrintTraverser traverser;
 344     dir.Traverse(traverser, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN);
 345 }
 346
 347 #if TEST_ALL
 348
 349 static void TestDirExists()
 350 {
 351     wxPuts(_T("*** Testing wxDir::Exists() ***"));
 352
 353     static const wxChar *dirnames[] =
 354     {
 355         _T("."),
 356 #if defined(__WXMSW__)
 357         _T("c:"),
 358         _T("c:\\"),
 359         _T("\\\\share\\file"),
 360         _T("c:\\dos"),
 361         _T("c:\\dos\\"),
 362         _T("c:\\dos\\\\"),
 363         _T("c:\\autoexec.bat"),
 364 #elif defined(__UNIX__)
 365         _T("/"),
 366         _T("//"),
 367         _T("/usr/bin"),
 368         _T("/usr//bin"),
 369         _T("/usr///bin"),
 370 #endif
 371     };
 372
 373     for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
 374     {
 375         wxPrintf(_T("%-40s: %s\n"),
 376                  dirnames[n],
 377                  wxDir::Exists(dirnames[n]) ? _T("exists")
 378                                             : _T("doesn't exist"));
 379     }
 380 }
 381
 382 #endif // TEST_ALL
 383
 384 #endif // TEST_DIR
 385
 386 // ----------------------------------------------------------------------------
 387 // wxDllLoader
 388 // ----------------------------------------------------------------------------
 389
 390 #ifdef TEST_DYNLIB
 391
 392 #include "wx/dynlib.h"
 393
 394 static void TestDllLoad()
 395 {
 396 #if defined(__WXMSW__)
 397     static const wxChar *LIB_NAME = _T("kernel32.dll");
 398     static const wxChar *FUNC_NAME = _T("lstrlenA");
 399 #elif defined(__UNIX__)
 400     // weird: using just libc.so does *not* work!
 401     static const wxChar *LIB_NAME = _T("/lib/libc.so.6");
 402     static const wxChar *FUNC_NAME = _T("strlen");
 403 #else
 404     #error "don't know how to test wxDllLoader on this platform"
 405 #endif
 406
 407     wxPuts(_T("*** testing basic wxDynamicLibrary functions ***\n"));
 408
 409     wxDynamicLibrary lib(LIB_NAME);
 410     if ( !lib.IsLoaded() )
 411     {
 412         wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
 413     }
 414     else
 415     {
 416         typedef int (wxSTDCALL *wxStrlenType)(const char *);
 417         wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
 418         if ( !pfnStrlen )
 419         {
 420             wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
 421                      FUNC_NAME, LIB_NAME);
 422         }
 423         else
 424         {
 425             wxPrintf(_T("Calling %s dynamically loaded from %s "),
 426                      FUNC_NAME, LIB_NAME);
 427
 428             if ( pfnStrlen("foo") != 3 )
 429             {
 430                 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
 431             }
 432             else
 433             {
 434                 wxPuts(_T("... ok"));
 435             }
 436         }
 437
 438 #ifdef __WXMSW__
 439         static const wxChar *FUNC_NAME_AW = _T("lstrlen");
 440
 441         typedef int (wxSTDCALL *wxStrlenTypeAorW)(const wxChar *);
 442         wxStrlenTypeAorW
 443             pfnStrlenAorW = (wxStrlenTypeAorW)lib.GetSymbolAorW(FUNC_NAME_AW);
 444         if ( !pfnStrlenAorW )
 445         {
 446             wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
 447                      FUNC_NAME_AW, LIB_NAME);
 448         }
 449         else
 450         {
 451             if ( pfnStrlenAorW(_T("foobar")) != 6 )
 452             {
 453                 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
 454             }
 455         }
 456 #endif // __WXMSW__
 457     }
 458 }
 459
 460 #if defined(__WXMSW__) || defined(__UNIX__)
 461
 462 static void TestDllListLoaded()
 463 {
 464     wxPuts(_T("*** testing wxDynamicLibrary::ListLoaded() ***\n"));
 465
 466     puts("\nLoaded modules:");
 467     wxDynamicLibraryDetailsArray dlls = wxDynamicLibrary::ListLoaded();
 468     const size_t count = dlls.GetCount();
 469     for ( size_t n = 0; n < count; ++n )
 470     {
 471         const wxDynamicLibraryDetails& details = dlls[n];
 472         printf("%-45s", (const char *)details.GetPath().mb_str());
 473
 474         void *addr;
 475         size_t len;
 476         if ( details.GetAddress(&addr, &len) )
 477         {
 478             printf(" %08lx:%08lx",
 479                    (unsigned long)addr, (unsigned long)((char *)addr + len));
 480         }
 481
 482         printf(" %s\n", (const char *)details.GetVersion().mb_str());
 483     }
 484 }
 485
 486 #endif
 487
 488 #endif // TEST_DYNLIB
 489
 490 // ----------------------------------------------------------------------------
 491 // wxGet/SetEnv
 492 // ----------------------------------------------------------------------------
 493
 494 #ifdef TEST_ENVIRON
 495
 496 #include "wx/utils.h"
 497
 498 static wxString MyGetEnv(const wxString& var)
 499 {
 500     wxString val;
 501     if ( !wxGetEnv(var, &val) )
 502         val = _T("<empty>");
 503     else
 504         val = wxString(_T('\'')) + val + _T('\'');
 505
 506     return val;
 507 }
 508
 509 static void TestEnvironment()
 510 {
 511     const wxChar *var = _T("wxTestVar");
 512
 513     wxPuts(_T("*** testing environment access functions ***"));
 514
 515     wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
 516     wxSetEnv(var, _T("value for wxTestVar"));
 517     wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 518     wxSetEnv(var, _T("another value"));
 519     wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 520     wxUnsetEnv(var);
 521     wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"),  var, MyGetEnv(var).c_str());
 522     wxPrintf(_T("PATH = %s\n"),  MyGetEnv(_T("PATH")).c_str());
 523 }
 524
 525 #endif // TEST_ENVIRON
 526
 527 // ----------------------------------------------------------------------------
 528 // wxExecute
 529 // ----------------------------------------------------------------------------
 530
 531 #ifdef TEST_EXECUTE
 532
 533 #include "wx/utils.h"
 534
 535 static void TestExecute()
 536 {
 537     wxPuts(_T("*** testing wxExecute ***"));
 538
 539 #ifdef __UNIX__
 540     #define COMMAND "echo hi"
 541     #define ASYNC_COMMAND "xclock"
 542     #define SHELL_COMMAND "echo hi from shell"
 543     #define REDIRECT_COMMAND "cat -n Makefile"
 544 #elif defined(__WXMSW__)
 545     #define COMMAND "command.com /c echo hi"
 546     #define ASYNC_COMMAND "notepad"
 547     #define SHELL_COMMAND "echo hi"
 548     #define REDIRECT_COMMAND COMMAND
 549 #else
 550     #error "no command to exec"
 551 #endif // OS
 552
 553     wxPrintf(_T("Testing wxShell: "));
 554     fflush(stdout);
 555     if ( wxShell(_T(SHELL_COMMAND)) )
 556         wxPuts(_T("Ok."));
 557     else
 558         wxPuts(_T("ERROR."));
 559
 560     wxPrintf(_T("Testing wxExecute: "));
 561     fflush(stdout);
 562     if ( wxExecute(_T(COMMAND), wxEXEC_SYNC) == 0 )
 563         wxPuts(_T("Ok."));
 564     else
 565         wxPuts(_T("ERROR."));
 566
 567     wxPrintf(_T("Testing async wxExecute: "));
 568     fflush(stdout);
 569     int pid = wxExecute(ASYNC_COMMAND);
 570     if ( pid != 0 )
 571     {
 572         wxPuts(_T("Ok (command launched)."));
 573         if ( wxKill(pid) == -1 )
 574             wxPuts("ERROR: failed to kill child process.");
 575     }
 576     else
 577         wxPuts(_T("ERROR."));
 578
 579     wxPrintf(_T("Testing wxExecute with redirection:\n"));
 580     wxArrayString output;
 581     if ( wxExecute(_T(REDIRECT_COMMAND), output) != 0 )
 582     {
 583         wxPuts(_T("ERROR."));
 584     }
 585     else
 586     {
 587         // don't show too much output, MAX_LINES is enough
 588         static const unsigned MAX_LINES = 20;
 589
 590         const unsigned count = output.size();
 591         for ( unsigned n = 0;
 592               n < (count > MAX_LINES ? MAX_LINES/2 : count);
 593               n++ )
 594         {
 595             wxPrintf("%04u:\t%s\n", n + 1, output[n]);
 596         }
 597
 598         if ( count > MAX_LINES )
 599         {
 600             wxPrintf("... skipping %u lines...\n", count - MAX_LINES);
 601
 602             for ( unsigned n = count - MAX_LINES/2; n < count; n++ )
 603             {
 604                 wxPrintf("%04u:\t%s\n", n + 1, output[n]);
 605             }
 606         }
 607
 608         wxPuts(_T("Ok."));
 609     }
 610 }
 611
 612 #endif // TEST_EXECUTE
 613
 614 // ----------------------------------------------------------------------------
 615 // file
 616 // ----------------------------------------------------------------------------
 617
 618 #ifdef TEST_FILE
 619
 620 #include "wx/file.h"
 621 #include "wx/ffile.h"
 622 #include "wx/textfile.h"
 623
 624 static void TestFileRead()
 625 {
 626     wxPuts(_T("*** wxFile read test ***"));
 627
 628     wxFile file(_T("testdata.fc"));
 629     if ( file.IsOpened() )
 630     {
 631         wxPrintf(_T("File length: %lu\n"), file.Length());
 632
 633         wxPuts(_T("File dump:\n----------"));
 634
 635         static const size_t len = 1024;
 636         wxChar buf[len];
 637         for ( ;; )
 638         {
 639             size_t nRead = file.Read(buf, len);
 640             if ( nRead == (size_t)wxInvalidOffset )
 641             {
 642                 wxPrintf(_T("Failed to read the file."));
 643                 break;
 644             }
 645
 646             fwrite(buf, nRead, 1, stdout);
 647
 648             if ( nRead < len )
 649                 break;
 650         }
 651
 652         wxPuts(_T("----------"));
 653     }
 654     else
 655     {
 656         wxPrintf(_T("ERROR: can't open test file.\n"));
 657     }
 658
 659     wxPuts(wxEmptyString);
 660 }
 661
 662 static void TestTextFileRead()
 663 {
 664     wxPuts(_T("*** wxTextFile read test ***"));
 665
 666     wxTextFile file(_T("testdata.fc"));
 667     if ( file.Open() )
 668     {
 669         wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
 670         wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
 671
 672         wxString s;
 673
 674         wxPuts(_T("\nDumping the entire file:"));
 675         for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
 676         {
 677             wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 678         }
 679         wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 680
 681         wxPuts(_T("\nAnd now backwards:"));
 682         for ( s = file.GetLastLine();
 683               file.GetCurrentLine() != 0;
 684               s = file.GetPrevLine() )
 685         {
 686             wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 687         }
 688         wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
 689     }
 690     else
 691     {
 692         wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
 693     }
 694
 695     wxPuts(wxEmptyString);
 696 }
 697
 698 static void TestFileCopy()
 699 {
 700     wxPuts(_T("*** Testing wxCopyFile ***"));
 701
 702     static const wxChar *filename1 = _T("testdata.fc");
 703     static const wxChar *filename2 = _T("test2");
 704     if ( !wxCopyFile(filename1, filename2) )
 705     {
 706         wxPuts(_T("ERROR: failed to copy file"));
 707     }
 708     else
 709     {
 710         wxFFile f1(filename1, _T("rb")),
 711                 f2(filename2, _T("rb"));
 712
 713         if ( !f1.IsOpened() || !f2.IsOpened() )
 714         {
 715             wxPuts(_T("ERROR: failed to open file(s)"));
 716         }
 717         else
 718         {
 719             wxString s1, s2;
 720             if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
 721             {
 722                 wxPuts(_T("ERROR: failed to read file(s)"));
 723             }
 724             else
 725             {
 726                 if ( (s1.length() != s2.length()) ||
 727                      (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
 728                 {
 729                     wxPuts(_T("ERROR: copy error!"));
 730                 }
 731                 else
 732                 {
 733                     wxPuts(_T("File was copied ok."));
 734                 }
 735             }
 736         }
 737     }
 738
 739     if ( !wxRemoveFile(filename2) )
 740     {
 741         wxPuts(_T("ERROR: failed to remove the file"));
 742     }
 743
 744     wxPuts(wxEmptyString);
 745 }
 746
 747 static void TestTempFile()
 748 {
 749     wxPuts(_T("*** wxTempFile test ***"));
 750
 751     wxTempFile tmpFile;
 752     if ( tmpFile.Open(_T("test2")) && tmpFile.Write(_T("the answer is 42")) )
 753     {
 754         if ( tmpFile.Commit() )
 755             wxPuts(_T("File committed."));
 756         else
 757             wxPuts(_T("ERROR: could't commit temp file."));
 758
 759         wxRemoveFile(_T("test2"));
 760     }
 761
 762     wxPuts(wxEmptyString);
 763 }
 764
 765 #endif // TEST_FILE
 766
 767 // ----------------------------------------------------------------------------
 768 // wxFileConfig
 769 // ----------------------------------------------------------------------------
 770
 771 #ifdef TEST_FILECONF
 772
 773 #include "wx/confbase.h"
 774 #include "wx/fileconf.h"
 775
 776 static const struct FileConfTestData
 777 {
 778     const wxChar *name;      // value name
 779     const wxChar *value;     // the value from the file
 780 } fcTestData[] =
 781 {
 782     { _T("value1"),                       _T("one") },
 783     { _T("value2"),                       _T("two") },
 784     { _T("novalue"),                      _T("default") },
 785 };
 786
 787 static void TestFileConfRead()
 788 {
 789     wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
 790
 791     wxFileConfig fileconf(_T("test"), wxEmptyString,
 792                           _T("testdata.fc"), wxEmptyString,
 793                           wxCONFIG_USE_RELATIVE_PATH);
 794
 795     // test simple reading
 796     wxPuts(_T("\nReading config file:"));
 797     wxString defValue(_T("default")), value;
 798     for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
 799     {
 800         const FileConfTestData& data = fcTestData[n];
 801         value = fileconf.Read(data.name, defValue);
 802         wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
 803         if ( value == data.value )
 804         {
 805             wxPuts(_T("(ok)"));
 806         }
 807         else
 808         {
 809             wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
 810         }
 811     }
 812
 813     // test enumerating the entries
 814     wxPuts(_T("\nEnumerating all root entries:"));
 815     long dummy;
 816     wxString name;
 817     bool cont = fileconf.GetFirstEntry(name, dummy);
 818     while ( cont )
 819     {
 820         wxPrintf(_T("\t%s = %s\n"),
 821                name.c_str(),
 822                fileconf.Read(name.c_str(), _T("ERROR")).c_str());
 823
 824         cont = fileconf.GetNextEntry(name, dummy);
 825     }
 826
 827     static const wxChar *testEntry = _T("TestEntry");
 828     wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
 829     fileconf.Write(testEntry, _T("A value"));
 830     fileconf.DeleteEntry(testEntry);
 831     wxPrintf(fileconf.HasEntry(testEntry) ? _T("ERROR\n") : _T("ok\n"));
 832 }
 833
 834 #endif // TEST_FILECONF
 835
 836 // ----------------------------------------------------------------------------
 837 // wxFileName
 838 // ----------------------------------------------------------------------------
 839
 840 #ifdef TEST_FILENAME
 841
 842 #include "wx/filename.h"
 843
 844 #if 0
 845 static void DumpFileName(const wxChar *desc, const wxFileName& fn)
 846 {
 847     wxPuts(desc);
 848
 849     wxString full = fn.GetFullPath();
 850
 851     wxString vol, path, name, ext;
 852     wxFileName::SplitPath(full, &vol, &path, &name, &ext);
 853
 854     wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
 855              full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
 856
 857     wxFileName::SplitPath(full, &path, &name, &ext);
 858     wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
 859              path.c_str(), name.c_str(), ext.c_str());
 860
 861     wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
 862     wxPrintf(_T("with volume: \t'%s'\n"),
 863              fn.GetPath(wxPATH_GET_VOLUME).c_str());
 864     wxPrintf(_T("with separator:\t'%s'\n"),
 865              fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
 866     wxPrintf(_T("with both:   \t'%s'\n"),
 867              fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
 868
 869     wxPuts(_T("The directories in the path are:"));
 870     wxArrayString dirs = fn.GetDirs();
 871     size_t count = dirs.GetCount();
 872     for ( size_t n = 0; n < count; n++ )
 873     {
 874         wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
 875     }
 876 }
 877 #endif
 878
 879 static void TestFileNameTemp()
 880 {
 881     wxPuts(_T("*** testing wxFileName temp file creation ***"));
 882
 883     static const wxChar *tmpprefixes[] =
 884     {
 885         _T(""),
 886         _T("foo"),
 887         _T(".."),
 888         _T("../bar"),
 889 #ifdef __UNIX__
 890         _T("/tmp/foo"),
 891         _T("/tmp/foo/bar"), // this one must be an error
 892 #endif // __UNIX__
 893     };
 894
 895     for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
 896     {
 897         wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
 898         if ( path.empty() )
 899         {
 900             // "error" is not in upper case because it may be ok
 901             wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
 902         }
 903         else
 904         {
 905             wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
 906                    tmpprefixes[n], path.c_str());
 907
 908             if ( !wxRemoveFile(path) )
 909             {
 910                 wxLogWarning(_T("Failed to remove temp file '%s'"),
 911                              path.c_str());
 912             }
 913         }
 914     }
 915 }
 916
 917 static void TestFileNameDirManip()
 918 {
 919     // TODO: test AppendDir(), RemoveDir(), ...
 920 }
 921
 922 static void TestFileNameComparison()
 923 {
 924     // TODO!
 925 }
 926
 927 static void TestFileNameOperations()
 928 {
 929     // TODO!
 930 }
 931
 932 static void TestFileNameCwd()
 933 {
 934     // TODO!
 935 }
 936
 937 #endif // TEST_FILENAME
 938
 939 // ----------------------------------------------------------------------------
 940 // wxFileName time functions
 941 // ----------------------------------------------------------------------------
 942
 943 #ifdef TEST_FILETIME
 944
 945 #include "wx/filename.h"
 946 #include "wx/datetime.h"
 947
 948 static void TestFileGetTimes()
 949 {
 950     wxFileName fn(_T("testdata.fc"));
 951
 952     wxDateTime dtAccess, dtMod, dtCreate;
 953     if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
 954     {
 955         wxPrintf(_T("ERROR: GetTimes() failed.\n"));
 956     }
 957     else
 958     {
 959         static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
 960
 961         wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
 962         wxPrintf(_T("Creation:    \t%s\n"), dtCreate.Format(fmt).c_str());
 963         wxPrintf(_T("Last read:   \t%s\n"), dtAccess.Format(fmt).c_str());
 964         wxPrintf(_T("Last write:  \t%s\n"), dtMod.Format(fmt).c_str());
 965     }
 966 }
 967
 968 #if 0
 969 static void TestFileSetTimes()
 970 {
 971     wxFileName fn(_T("testdata.fc"));
 972
 973     if ( !fn.Touch() )
 974     {
 975         wxPrintf(_T("ERROR: Touch() failed.\n"));
 976     }
 977 }
 978 #endif
 979
 980 #endif // TEST_FILETIME
 981
 982 // ----------------------------------------------------------------------------
 983 // wxLocale
 984 // ----------------------------------------------------------------------------
 985
 986 #ifdef TEST_LOCALE
 987
 988 #include "wx/intl.h"
 989 #include "wx/utils.h"   // for wxSetEnv
 990
 991 static wxLocale gs_localeDefault;
 992     // NOTE: don't init it here as it needs a wxAppTraits object
 993     //       and thus must be init-ed after creation of the wxInitializer
 994     //       class in the main()
 995
 996 // find the name of the language from its value
 997 static const wxChar *GetLangName(int lang)
 998 {
 999     static const wxChar *languageNames[] =
1000     {
1001         _T("DEFAULT"),
1002         _T("UNKNOWN"),
1003         _T("ABKHAZIAN"),
1004         _T("AFAR"),
1005         _T("AFRIKAANS"),
1006         _T("ALBANIAN"),
1007         _T("AMHARIC"),
1008         _T("ARABIC"),
1009         _T("ARABIC_ALGERIA"),
1010         _T("ARABIC_BAHRAIN"),
1011         _T("ARABIC_EGYPT"),
1012         _T("ARABIC_IRAQ"),
1013         _T("ARABIC_JORDAN"),
1014         _T("ARABIC_KUWAIT"),
1015         _T("ARABIC_LEBANON"),
1016         _T("ARABIC_LIBYA"),
1017         _T("ARABIC_MOROCCO"),
1018         _T("ARABIC_OMAN"),
1019         _T("ARABIC_QATAR"),
1020         _T("ARABIC_SAUDI_ARABIA"),
1021         _T("ARABIC_SUDAN"),
1022         _T("ARABIC_SYRIA"),
1023         _T("ARABIC_TUNISIA"),
1024         _T("ARABIC_UAE"),
1025         _T("ARABIC_YEMEN"),
1026         _T("ARMENIAN"),
1027         _T("ASSAMESE"),
1028         _T("AYMARA"),
1029         _T("AZERI"),
1030         _T("AZERI_CYRILLIC"),
1031         _T("AZERI_LATIN"),
1032         _T("BASHKIR"),
1033         _T("BASQUE"),
1034         _T("BELARUSIAN"),
1035         _T("BENGALI"),
1036         _T("BHUTANI"),
1037         _T("BIHARI"),
1038         _T("BISLAMA"),
1039         _T("BRETON"),
1040         _T("BULGARIAN"),
1041         _T("BURMESE"),
1042         _T("CAMBODIAN"),
1043         _T("CATALAN"),
1044         _T("CHINESE"),
1045         _T("CHINESE_SIMPLIFIED"),
1046         _T("CHINESE_TRADITIONAL"),
1047         _T("CHINESE_HONGKONG"),
1048         _T("CHINESE_MACAU"),
1049         _T("CHINESE_SINGAPORE"),
1050         _T("CHINESE_TAIWAN"),
1051         _T("CORSICAN"),
1052         _T("CROATIAN"),
1053         _T("CZECH"),
1054         _T("DANISH"),
1055         _T("DUTCH"),
1056         _T("DUTCH_BELGIAN"),
1057         _T("ENGLISH"),
1058         _T("ENGLISH_UK"),
1059         _T("ENGLISH_US"),
1060         _T("ENGLISH_AUSTRALIA"),
1061         _T("ENGLISH_BELIZE"),
1062         _T("ENGLISH_BOTSWANA"),
1063         _T("ENGLISH_CANADA"),
1064         _T("ENGLISH_CARIBBEAN"),
1065         _T("ENGLISH_DENMARK"),
1066         _T("ENGLISH_EIRE"),
1067         _T("ENGLISH_JAMAICA"),
1068         _T("ENGLISH_NEW_ZEALAND"),
1069         _T("ENGLISH_PHILIPPINES"),
1070         _T("ENGLISH_SOUTH_AFRICA"),
1071         _T("ENGLISH_TRINIDAD"),
1072         _T("ENGLISH_ZIMBABWE"),
1073         _T("ESPERANTO"),
1074         _T("ESTONIAN"),
1075         _T("FAEROESE"),
1076         _T("FARSI"),
1077         _T("FIJI"),
1078         _T("FINNISH"),
1079         _T("FRENCH"),
1080         _T("FRENCH_BELGIAN"),
1081         _T("FRENCH_CANADIAN"),
1082         _T("FRENCH_LUXEMBOURG"),
1083         _T("FRENCH_MONACO"),
1084         _T("FRENCH_SWISS"),
1085         _T("FRISIAN"),
1086         _T("GALICIAN"),
1087         _T("GEORGIAN"),
1088         _T("GERMAN"),
1089         _T("GERMAN_AUSTRIAN"),
1090         _T("GERMAN_BELGIUM"),
1091         _T("GERMAN_LIECHTENSTEIN"),
1092         _T("GERMAN_LUXEMBOURG"),
1093         _T("GERMAN_SWISS"),
1094         _T("GREEK"),
1095         _T("GREENLANDIC"),
1096         _T("GUARANI"),
1097         _T("GUJARATI"),
1098         _T("HAUSA"),
1099         _T("HEBREW"),
1100         _T("HINDI"),
1101         _T("HUNGARIAN"),
1102         _T("ICELANDIC"),
1103         _T("INDONESIAN"),
1104         _T("INTERLINGUA"),
1105         _T("INTERLINGUE"),
1106         _T("INUKTITUT"),
1107         _T("INUPIAK"),
1108         _T("IRISH"),
1109         _T("ITALIAN"),
1110         _T("ITALIAN_SWISS"),
1111         _T("JAPANESE"),
1112         _T("JAVANESE"),
1113         _T("KANNADA"),
1114         _T("KASHMIRI"),
1115         _T("KASHMIRI_INDIA"),
1116         _T("KAZAKH"),
1117         _T("KERNEWEK"),
1118         _T("KINYARWANDA"),
1119         _T("KIRGHIZ"),
1120         _T("KIRUNDI"),
1121         _T("KONKANI"),
1122         _T("KOREAN"),
1123         _T("KURDISH"),
1124         _T("LAOTHIAN"),
1125         _T("LATIN"),
1126         _T("LATVIAN"),
1127         _T("LINGALA"),
1128         _T("LITHUANIAN"),
1129         _T("MACEDONIAN"),
1130         _T("MALAGASY"),
1131         _T("MALAY"),
1132         _T("MALAYALAM"),
1133         _T("MALAY_BRUNEI_DARUSSALAM"),
1134         _T("MALAY_MALAYSIA"),
1135         _T("MALTESE"),
1136         _T("MANIPURI"),
1137         _T("MAORI"),
1138         _T("MARATHI"),
1139         _T("MOLDAVIAN"),
1140         _T("MONGOLIAN"),
1141         _T("NAURU"),
1142         _T("NEPALI"),
1143         _T("NEPALI_INDIA"),
1144         _T("NORWEGIAN_BOKMAL"),
1145         _T("NORWEGIAN_NYNORSK"),
1146         _T("OCCITAN"),
1147         _T("ORIYA"),
1148         _T("OROMO"),
1149         _T("PASHTO"),
1150         _T("POLISH"),
1151         _T("PORTUGUESE"),
1152         _T("PORTUGUESE_BRAZILIAN"),
1153         _T("PUNJABI"),
1154         _T("QUECHUA"),
1155         _T("RHAETO_ROMANCE"),
1156         _T("ROMANIAN"),
1157         _T("RUSSIAN"),
1158         _T("RUSSIAN_UKRAINE"),
1159         _T("SAMOAN"),
1160         _T("SANGHO"),
1161         _T("SANSKRIT"),
1162         _T("SCOTS_GAELIC"),
1163         _T("SERBIAN"),
1164         _T("SERBIAN_CYRILLIC"),
1165         _T("SERBIAN_LATIN"),
1166         _T("SERBO_CROATIAN"),
1167         _T("SESOTHO"),
1168         _T("SETSWANA"),
1169         _T("SHONA"),
1170         _T("SINDHI"),
1171         _T("SINHALESE"),
1172         _T("SISWATI"),
1173         _T("SLOVAK"),
1174         _T("SLOVENIAN"),
1175         _T("SOMALI"),
1176         _T("SPANISH"),
1177         _T("SPANISH_ARGENTINA"),
1178         _T("SPANISH_BOLIVIA"),
1179         _T("SPANISH_CHILE"),
1180         _T("SPANISH_COLOMBIA"),
1181         _T("SPANISH_COSTA_RICA"),
1182         _T("SPANISH_DOMINICAN_REPUBLIC"),
1183         _T("SPANISH_ECUADOR"),
1184         _T("SPANISH_EL_SALVADOR"),
1185         _T("SPANISH_GUATEMALA"),
1186         _T("SPANISH_HONDURAS"),
1187         _T("SPANISH_MEXICAN"),
1188         _T("SPANISH_MODERN"),
1189         _T("SPANISH_NICARAGUA"),
1190         _T("SPANISH_PANAMA"),
1191         _T("SPANISH_PARAGUAY"),
1192         _T("SPANISH_PERU"),
1193         _T("SPANISH_PUERTO_RICO"),
1194         _T("SPANISH_URUGUAY"),
1195         _T("SPANISH_US"),
1196         _T("SPANISH_VENEZUELA"),
1197         _T("SUNDANESE"),
1198         _T("SWAHILI"),
1199         _T("SWEDISH"),
1200         _T("SWEDISH_FINLAND"),
1201         _T("TAGALOG"),
1202         _T("TAJIK"),
1203         _T("TAMIL"),
1204         _T("TATAR"),
1205         _T("TELUGU"),
1206         _T("THAI"),
1207         _T("TIBETAN"),
1208         _T("TIGRINYA"),
1209         _T("TONGA"),
1210         _T("TSONGA"),
1211         _T("TURKISH"),
1212         _T("TURKMEN"),
1213         _T("TWI"),
1214         _T("UIGHUR"),
1215         _T("UKRAINIAN"),
1216         _T("URDU"),
1217         _T("URDU_INDIA"),
1218         _T("URDU_PAKISTAN"),
1219         _T("UZBEK"),
1220         _T("UZBEK_CYRILLIC"),
1221         _T("UZBEK_LATIN"),
1222         _T("VIETNAMESE"),
1223         _T("VOLAPUK"),
1224         _T("WELSH"),
1225         _T("WOLOF"),
1226         _T("XHOSA"),
1227         _T("YIDDISH"),
1228         _T("YORUBA"),
1229         _T("ZHUANG"),
1230         _T("ZULU"),
1231     };
1232
1233     if ( (size_t)lang < WXSIZEOF(languageNames) )
1234         return languageNames[lang];
1235     else
1236         return _T("INVALID");
1237 }
1238
1239 static void TestDefaultLang()
1240 {
1241     wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
1242
1243     gs_localeDefault.Init(wxLANGUAGE_ENGLISH);
1244
1245     static const wxChar *langStrings[] =
1246     {
1247         NULL,               // system default
1248         _T("C"),
1249         _T("fr"),
1250         _T("fr_FR"),
1251         _T("en"),
1252         _T("en_GB"),
1253         _T("en_US"),
1254         _T("de_DE.iso88591"),
1255         _T("german"),
1256         _T("?"),            // invalid lang spec
1257         _T("klingonese"),   // I bet on some systems it does exist...
1258     };
1259
1260     wxPrintf(_T("The default system encoding is %s (%d)\n"),
1261              wxLocale::GetSystemEncodingName().c_str(),
1262              wxLocale::GetSystemEncoding());
1263
1264     for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1265     {
1266         const wxChar *langStr = langStrings[n];
1267         if ( langStr )
1268         {
1269             // FIXME: this doesn't do anything at all under Windows, we need
1270             //        to create a new wxLocale!
1271             wxSetEnv(_T("LC_ALL"), langStr);
1272         }
1273
1274         int lang = gs_localeDefault.GetSystemLanguage();
1275         wxPrintf(_T("Locale for '%s' is %s.\n"),
1276                  langStr ? langStr : _T("system default"), GetLangName(lang));
1277     }
1278 }
1279
1280 #endif // TEST_LOCALE
1281
1282 // ----------------------------------------------------------------------------
1283 // MIME types
1284 // ----------------------------------------------------------------------------
1285
1286 #ifdef TEST_MIME
1287
1288 #include "wx/mimetype.h"
1289
1290 static void TestMimeEnum()
1291 {
1292     wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1293
1294     wxArrayString mimetypes;
1295
1296     size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1297
1298     wxPrintf(_T("*** All %u known filetypes: ***\n"), count);
1299
1300     wxArrayString exts;
1301     wxString desc;
1302
1303     for ( size_t n = 0; n < count; n++ )
1304     {
1305         wxFileType *filetype =
1306             wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1307         if ( !filetype )
1308         {
1309             wxPrintf(_T("nothing known about the filetype '%s'!\n"),
1310                    mimetypes[n].c_str());
1311             continue;
1312         }
1313
1314         filetype->GetDescription(&desc);
1315         filetype->GetExtensions(exts);
1316
1317         filetype->GetIcon(NULL);
1318
1319         wxString extsAll;
1320         for ( size_t e = 0; e < exts.GetCount(); e++ )
1321         {
1322             if ( e > 0 )
1323                 extsAll << _T(", ");
1324             extsAll += exts[e];
1325         }
1326
1327         wxPrintf(_T("\t%s: %s (%s)\n"),
1328                mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1329     }
1330
1331     wxPuts(wxEmptyString);
1332 }
1333
1334 static void TestMimeFilename()
1335 {
1336     wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1337
1338     static const wxChar *filenames[] =
1339     {
1340         _T("readme.txt"),
1341         _T("document.pdf"),
1342         _T("image.gif"),
1343         _T("picture.jpeg"),
1344     };
1345
1346     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1347     {
1348         const wxString fname = filenames[n];
1349         wxString ext = fname.AfterLast(_T('.'));
1350         wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1351         if ( !ft )
1352         {
1353             wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1354         }
1355         else
1356         {
1357             wxString desc;
1358             if ( !ft->GetDescription(&desc) )
1359                 desc = _T("<no description>");
1360
1361             wxString cmd;
1362             if ( !ft->GetOpenCommand(&cmd,
1363                                      wxFileType::MessageParameters(fname, wxEmptyString)) )
1364                 cmd = _T("<no command available>");
1365             else
1366                 cmd = wxString(_T('"')) + cmd + _T('"');
1367
1368             wxPrintf(_T("To open %s (%s) do %s.\n"),
1369                      fname.c_str(), desc.c_str(), cmd.c_str());
1370
1371             delete ft;
1372         }
1373     }
1374
1375     wxPuts(wxEmptyString);
1376 }
1377
1378 // these tests were broken by wxMimeTypesManager changes, temporarily disabling
1379 #if 0
1380
1381 static void TestMimeOverride()
1382 {
1383     wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1384
1385     static const wxChar *mailcap = _T("/tmp/mailcap");
1386     static const wxChar *mimetypes = _T("/tmp/mime.types");
1387
1388     if ( wxFile::Exists(mailcap) )
1389         wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1390                  mailcap,
1391                  wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
1392     else
1393         wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1394                  mailcap);
1395
1396     if ( wxFile::Exists(mimetypes) )
1397         wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1398                  mimetypes,
1399                  wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
1400     else
1401         wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1402                  mimetypes);
1403
1404     wxPuts(wxEmptyString);
1405 }
1406
1407 static void TestMimeAssociate()
1408 {
1409     wxPuts(_T("*** Testing creation of filetype association ***\n"));
1410
1411     wxFileTypeInfo ftInfo(
1412                             _T("application/x-xyz"),
1413                             _T("xyzview '%s'"), // open cmd
1414                             _T(""),             // print cmd
1415                             _T("XYZ File"),     // description
1416                             _T(".xyz"),         // extensions
1417                             wxNullPtr           // end of extensions
1418                          );
1419     ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1420
1421     wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1422     if ( !ft )
1423     {
1424         wxPuts(_T("ERROR: failed to create association!"));
1425     }
1426     else
1427     {
1428         // TODO: read it back
1429         delete ft;
1430     }
1431
1432     wxPuts(wxEmptyString);
1433 }
1434
1435 #endif // 0
1436
1437 #endif // TEST_MIME
1438
1439 // ----------------------------------------------------------------------------
1440 // module dependencies feature
1441 // ----------------------------------------------------------------------------
1442
1443 #ifdef TEST_MODULE
1444
1445 #include "wx/module.h"
1446
1447 class wxTestModule : public wxModule
1448 {
1449 protected:
1450     virtual bool OnInit() { wxPrintf(_T("Load module: %s\n"), GetClassInfo()->GetClassName()); return true; }
1451     virtual void OnExit() { wxPrintf(_T("Unload module: %s\n"), GetClassInfo()->GetClassName()); }
1452 };
1453
1454 class wxTestModuleA : public wxTestModule
1455 {
1456 public:
1457     wxTestModuleA();
1458 private:
1459     DECLARE_DYNAMIC_CLASS(wxTestModuleA)
1460 };
1461
1462 class wxTestModuleB : public wxTestModule
1463 {
1464 public:
1465     wxTestModuleB();
1466 private:
1467     DECLARE_DYNAMIC_CLASS(wxTestModuleB)
1468 };
1469
1470 class wxTestModuleC : public wxTestModule
1471 {
1472 public:
1473     wxTestModuleC();
1474 private:
1475     DECLARE_DYNAMIC_CLASS(wxTestModuleC)
1476 };
1477
1478 class wxTestModuleD : public wxTestModule
1479 {
1480 public:
1481     wxTestModuleD();
1482 private:
1483     DECLARE_DYNAMIC_CLASS(wxTestModuleD)
1484 };
1485
1486 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleC, wxModule)
1487 wxTestModuleC::wxTestModuleC()
1488 {
1489     AddDependency(CLASSINFO(wxTestModuleD));
1490 }
1491
1492 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleA, wxModule)
1493 wxTestModuleA::wxTestModuleA()
1494 {
1495     AddDependency(CLASSINFO(wxTestModuleB));
1496     AddDependency(CLASSINFO(wxTestModuleD));
1497 }
1498
1499 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleD, wxModule)
1500 wxTestModuleD::wxTestModuleD()
1501 {
1502 }
1503
1504 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleB, wxModule)
1505 wxTestModuleB::wxTestModuleB()
1506 {
1507     AddDependency(CLASSINFO(wxTestModuleD));
1508     AddDependency(CLASSINFO(wxTestModuleC));
1509 }
1510
1511 #endif // TEST_MODULE
1512
1513 // ----------------------------------------------------------------------------
1514 // misc information functions
1515 // ----------------------------------------------------------------------------
1516
1517 #ifdef TEST_INFO_FUNCTIONS
1518
1519 #include "wx/utils.h"
1520
1521 #if TEST_INTERACTIVE
1522 static void TestDiskInfo()
1523 {
1524     wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
1525
1526     for ( ;; )
1527     {
1528         wxChar pathname[128];
1529         wxPrintf(_T("\nEnter a directory name: "));
1530         if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
1531             break;
1532
1533         // kill the last '\n'
1534         pathname[wxStrlen(pathname) - 1] = 0;
1535
1536         wxLongLong total, free;
1537         if ( !wxGetDiskSpace(pathname, &total, &free) )
1538         {
1539             wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1540         }
1541         else
1542         {
1543             wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1544                     (total / 1024).ToString().c_str(),
1545                     (free / 1024).ToString().c_str(),
1546                     pathname);
1547         }
1548     }
1549 }
1550 #endif // TEST_INTERACTIVE
1551
1552 static void TestOsInfo()
1553 {
1554     wxPuts(_T("*** Testing OS info functions ***\n"));
1555
1556     int major, minor;
1557     wxGetOsVersion(&major, &minor);
1558     wxPrintf(_T("Running under: %s, version %d.%d\n"),
1559             wxGetOsDescription().c_str(), major, minor);
1560
1561     wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());
1562
1563     wxPrintf(_T("Host name is %s (%s).\n"),
1564            wxGetHostName().c_str(), wxGetFullHostName().c_str());
1565
1566     wxPuts(wxEmptyString);
1567 }
1568
1569 static void TestPlatformInfo()
1570 {
1571     wxPuts(_T("*** Testing wxPlatformInfo functions ***\n"));
1572
1573     // get this platform
1574     wxPlatformInfo plat;
1575
1576     wxPrintf(_T("Operating system family name is: %s\n"), plat.GetOperatingSystemFamilyName().c_str());
1577     wxPrintf(_T("Operating system name is: %s\n"), plat.GetOperatingSystemIdName().c_str());
1578     wxPrintf(_T("Port ID name is: %s\n"), plat.GetPortIdName().c_str());
1579     wxPrintf(_T("Port ID short name is: %s\n"), plat.GetPortIdShortName().c_str());
1580     wxPrintf(_T("Architecture is: %s\n"), plat.GetArchName().c_str());
1581     wxPrintf(_T("Endianness is: %s\n"), plat.GetEndiannessName().c_str());
1582
1583     wxPuts(wxEmptyString);
1584 }
1585
1586 static void TestUserInfo()
1587 {
1588     wxPuts(_T("*** Testing user info functions ***\n"));
1589
1590     wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
1591     wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
1592     wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
1593     wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
1594
1595     wxPuts(wxEmptyString);
1596 }
1597
1598 #endif // TEST_INFO_FUNCTIONS
1599
1600 // ----------------------------------------------------------------------------
1601 // path list
1602 // ----------------------------------------------------------------------------
1603
1604 #ifdef TEST_PATHLIST
1605
1606 #ifdef __UNIX__
1607     #define CMD_IN_PATH _T("ls")
1608 #else
1609     #define CMD_IN_PATH _T("command.com")
1610 #endif
1611
1612 static void TestPathList()
1613 {
1614     wxPuts(_T("*** Testing wxPathList ***\n"));
1615
1616     wxPathList pathlist;
1617     pathlist.AddEnvList(_T("PATH"));
1618     wxString path = pathlist.FindValidPath(CMD_IN_PATH);
1619     if ( path.empty() )
1620     {
1621         wxPrintf(_T("ERROR: command not found in the path.\n"));
1622     }
1623     else
1624     {
1625         wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
1626     }
1627 }
1628
1629 #endif // TEST_PATHLIST
1630
1631 // ----------------------------------------------------------------------------
1632 // regular expressions
1633 // ----------------------------------------------------------------------------
1634
1635 #ifdef TEST_REGEX
1636
1637 #include "wx/regex.h"
1638
1639 static void TestRegExInteractive()
1640 {
1641     wxPuts(_T("*** Testing RE interactively ***"));
1642
1643     for ( ;; )
1644     {
1645         wxChar pattern[128];
1646         wxPrintf(_T("\nEnter a pattern: "));
1647         if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
1648             break;
1649
1650         // kill the last '\n'
1651         pattern[wxStrlen(pattern) - 1] = 0;
1652
1653         wxRegEx re;
1654         if ( !re.Compile(pattern) )
1655         {
1656             continue;
1657         }
1658
1659         wxChar text[128];
1660         for ( ;; )
1661         {
1662             wxPrintf(_T("Enter text to match: "));
1663             if ( !wxFgets(text, WXSIZEOF(text), stdin) )
1664                 break;
1665
1666             // kill the last '\n'
1667             text[wxStrlen(text) - 1] = 0;
1668
1669             if ( !re.Matches(text) )
1670             {
1671                 wxPrintf(_T("No match.\n"));
1672             }
1673             else
1674             {
1675                 wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
1676
1677                 size_t start, len;
1678                 for ( size_t n = 1; ; n++ )
1679                 {
1680                     if ( !re.GetMatch(&start, &len, n) )
1681                     {
1682                         break;
1683                     }
1684
1685                     wxPrintf(_T("Subexpr %u matched '%s'\n"),
1686                              n, wxString(text + start, len).c_str());
1687                 }
1688             }
1689         }
1690     }
1691 }
1692
1693 #endif // TEST_REGEX
1694
1695 // ----------------------------------------------------------------------------
1696 // printf() tests
1697 // ----------------------------------------------------------------------------
1698
1699 /*
1700    NB: this stuff was taken from the glibc test suite and modified to build
1701        in wxWidgets: if I read the copyright below properly, this shouldn't
1702        be a problem
1703  */
1704
1705 #ifdef TEST_PRINTF
1706
1707 #ifdef wxTEST_PRINTF
1708     // use our functions from wxchar.cpp
1709     #undef wxPrintf
1710     #undef wxSprintf
1711
1712     // NB: do _not_ use ATTRIBUTE_PRINTF here, we have some invalid formats
1713     //     in the tests below
1714     int wxPrintf( const wxChar *format, ... );
1715     int wxSprintf( wxChar *str, const wxChar *format, ... );
1716 #endif
1717
1718 #include "wx/longlong.h"
1719
1720 #include <float.h>
1721
1722 static void rfg1 (void);
1723 static void rfg2 (void);
1724
1725
1726 static void
1727 fmtchk (const wxChar *fmt)
1728 {
1729   (void) wxPrintf(_T("%s:\t`"), fmt);
1730   (void) wxPrintf(fmt, 0x12);
1731   (void) wxPrintf(_T("'\n"));
1732 }
1733
1734 static void
1735 fmtst1chk (const wxChar *fmt)
1736 {
1737   (void) wxPrintf(_T("%s:\t`"), fmt);
1738   (void) wxPrintf(fmt, 4, 0x12);
1739   (void) wxPrintf(_T("'\n"));
1740 }
1741
1742 static void
1743 fmtst2chk (const wxChar *fmt)
1744 {
1745   (void) wxPrintf(_T("%s:\t`"), fmt);
1746   (void) wxPrintf(fmt, 4, 4, 0x12);
1747   (void) wxPrintf(_T("'\n"));
1748 }
1749
1750 /* This page is covered by the following copyright: */
1751
1752 /* (C) Copyright C E Chew
1753  *
1754  * Feel free to copy, use and distribute this software provided:
1755  *
1756  *        1. you do not pretend that you wrote it
1757  *        2. you leave this copyright notice intact.
1758  */
1759
1760 /*
1761  * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
1762  */
1763
1764 #define DEC -123
1765 #define INT 255
1766 #define UNS (~0)
1767
1768 /* Formatted Output Test
1769  *
1770  * This exercises the output formatting code.
1771  */
1772
1773 wxChar *PointerNull = NULL;
1774
1775 static void
1776 fp_test (void)
1777 {
1778   int i, j, k, l;
1779   wxChar buf[7];
1780   wxChar *prefix = buf;
1781   wxChar tp[20];
1782
1783   wxPuts(_T("\nFormatted output test"));
1784   wxPrintf(_T("prefix  6d      6o      6x      6X      6u\n"));
1785   wxStrcpy(prefix, _T("%"));
1786   for (i = 0; i < 2; i++) {
1787     for (j = 0; j < 2; j++) {
1788       for (k = 0; k < 2; k++) {
1789         for (l = 0; l < 2; l++) {
1790           wxStrcpy(prefix, _T("%"));
1791           if (i == 0) wxStrcat(prefix, _T("-"));
1792           if (j == 0) wxStrcat(prefix, _T("+"));
1793           if (k == 0) wxStrcat(prefix, _T("#"));
1794           if (l == 0) wxStrcat(prefix, _T("0"));
1795           wxPrintf(_T("%5s |"), prefix);
1796           wxStrcpy(tp, prefix);
1797           wxStrcat(tp, _T("6d |"));
1798           wxPrintf(tp, DEC);
1799           wxStrcpy(tp, prefix);
1800           wxStrcat(tp, _T("6o |"));
1801           wxPrintf(tp, INT);
1802           wxStrcpy(tp, prefix);
1803           wxStrcat(tp, _T("6x |"));
1804           wxPrintf(tp, INT);
1805           wxStrcpy(tp, prefix);
1806           wxStrcat(tp, _T("6X |"));
1807           wxPrintf(tp, INT);
1808           wxStrcpy(tp, prefix);
1809           wxStrcat(tp, _T("6u |"));
1810           wxPrintf(tp, UNS);
1811           wxPrintf(_T("\n"));
1812         }
1813       }
1814     }
1815   }
1816   wxPrintf(_T("%10s\n"), PointerNull);
1817   wxPrintf(_T("%-10s\n"), PointerNull);
1818 }
1819
1820 static void TestPrintf()
1821 {
1822   static wxChar shortstr[] = _T("Hi, Z.");
1823   static wxChar longstr[] = _T("Good morning, Doctor Chandra.  This is Hal.  \
1824 I am ready for my first lesson today.");
1825   int result = 0;
1826   wxString test_format;
1827
1828   fmtchk(_T("%.4x"));
1829   fmtchk(_T("%04x"));
1830   fmtchk(_T("%4.4x"));
1831   fmtchk(_T("%04.4x"));
1832   fmtchk(_T("%4.3x"));
1833   fmtchk(_T("%04.3x"));
1834
1835   fmtst1chk(_T("%.*x"));
1836   fmtst1chk(_T("%0*x"));
1837   fmtst2chk(_T("%*.*x"));
1838   fmtst2chk(_T("%0*.*x"));
1839
1840   wxString bad_format = _T("bad format:\t\"%b\"\n");
1841   wxPrintf(bad_format.c_str());
1842   wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
1843
1844   wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
1845   wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
1846   wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
1847   wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
1848   wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
1849   wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
1850   wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
1851   test_format = _T("left-adjusted ZLDN:\t\"%-010ld\"\n");
1852   wxPrintf(test_format.c_str(), -123456);
1853   wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
1854   wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
1855
1856   test_format = _T("zero-padded string:\t\"%010s\"\n");
1857   wxPrintf(test_format.c_str(), shortstr);
1858   test_format = _T("left-adjusted Z string:\t\"%-010s\"\n");
1859   wxPrintf(test_format.c_str(), shortstr);
1860   wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
1861   wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
1862   wxPrintf(_T("null string:\t\"%s\"\n"), PointerNull);
1863   wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr);
1864
1865   wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
1866   wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
1867   wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
1868   wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20);
1869   wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
1870   wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
1871   wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
1872   wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
1873   wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
1874   wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
1875   wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
1876   wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20);
1877
1878   wxPrintf (_T(" %6.5f\n"), .099999999860301614);
1879   wxPrintf (_T(" %6.5f\n"), .1);
1880   wxPrintf (_T("x%5.4fx\n"), .5);
1881
1882   wxPrintf (_T("%#03x\n"), 1);
1883
1884   //wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
1885
1886   {
1887     double d = FLT_MIN;
1888     int niter = 17;
1889
1890     while (niter-- != 0)
1891       wxPrintf (_T("%.17e\n"), d / 2);
1892     fflush (stdout);
1893   }
1894
1895 #ifndef __WATCOMC__
1896   // Open Watcom cause compiler error here
1897   // Error! E173: col(24) floating-point constant too small to represent
1898   wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
1899 #endif
1900
1901 #define FORMAT _T("|%12.4f|%12.4e|%12.4g|\n")
1902   wxPrintf (FORMAT, 0.0, 0.0, 0.0);
1903   wxPrintf (FORMAT, 1.0, 1.0, 1.0);
1904   wxPrintf (FORMAT, -1.0, -1.0, -1.0);
1905   wxPrintf (FORMAT, 100.0, 100.0, 100.0);
1906   wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
1907   wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
1908   wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
1909   wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
1910   wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
1911 #undef        FORMAT
1912
1913   {
1914     wxChar buf[20];
1915     int rc = wxSnprintf (buf, WXSIZEOF(buf), _T("%30s"), _T("foo"));
1916
1917     wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
1918              rc, WXSIZEOF(buf), buf);
1919 #if 0
1920     wxChar buf2[512];
1921     wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
1922             wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
1923 #endif
1924   }
1925
1926   fp_test ();
1927
1928   wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
1929   wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
1930   wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
1931   wxPrintf (_T("%g should be 123.456\n"), 123.456);
1932   wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
1933   wxPrintf (_T("%g should be 10\n"), 10.0);
1934   wxPrintf (_T("%g should be 0.02\n"), 0.02);
1935
1936   {
1937     double x=1.0;
1938     wxPrintf(_T("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
1939   }
1940
1941   {
1942     wxChar buf[200];
1943
1944     wxSprintf(buf,_T("%*s%*s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
1945
1946     result |= wxStrcmp (buf,
1947                       _T("onetwo                 three                         "));
1948
1949     wxPuts (result != 0 ? _T("Test failed!") : _T("Test ok."));
1950   }
1951
1952 #ifdef wxLongLong_t
1953   {
1954       wxChar buf[200];
1955
1956       wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
1957       #if 0
1958         // for some reason below line fails under Borland
1959       wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
1960       #endif
1961
1962       if (wxStrcmp (buf, _T("40000000000")) != 0)
1963       {
1964           result = 1;
1965           wxPuts (_T("\tFAILED"));
1966       }
1967       wxUnusedVar(result);
1968       wxPuts (wxEmptyString);
1969   }
1970 #endif // wxLongLong_t
1971
1972   wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
1973   wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
1974
1975   wxPuts (_T("--- Should be no further output. ---"));
1976   rfg1 ();
1977   rfg2 ();
1978
1979 #if 0
1980   {
1981     wxChar bytes[7];
1982     wxChar buf[20];
1983
1984     memset (bytes, '\xff', sizeof bytes);
1985     wxSprintf (buf, _T("foo%hhn\n"), &bytes[3]);
1986     if (bytes[0] != '\xff' || bytes[1] != '\xff' || bytes[2] != '\xff'
1987         || bytes[4] != '\xff' || bytes[5] != '\xff' || bytes[6] != '\xff')
1988       {
1989         wxPuts (_T("%hhn overwrite more bytes"));
1990         result = 1;
1991       }
1992     if (bytes[3] != 3)
1993       {
1994         wxPuts (_T("%hhn wrote incorrect value"));
1995         result = 1;
1996       }
1997   }
1998 #endif
1999 }
2000
2001 static void
2002 rfg1 (void)
2003 {
2004   wxChar buf[100];
2005
2006   wxSprintf (buf, _T("%5.s"), _T("xyz"));
2007   if (wxStrcmp (buf, _T("     ")) != 0)
2008     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("     "));
2009   wxSprintf (buf, _T("%5.f"), 33.3);
2010   if (wxStrcmp (buf, _T("   33")) != 0)
2011     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   33"));
2012   wxSprintf (buf, _T("%8.e"), 33.3e7);
2013   if (wxStrcmp (buf, _T("   3e+08")) != 0)
2014     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   3e+08"));
2015   wxSprintf (buf, _T("%8.E"), 33.3e7);
2016   if (wxStrcmp (buf, _T("   3E+08")) != 0)
2017     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("   3E+08"));
2018   wxSprintf (buf, _T("%.g"), 33.3);
2019   if (wxStrcmp (buf, _T("3e+01")) != 0)
2020     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3e+01"));
2021   wxSprintf (buf, _T("%.G"), 33.3);
2022   if (wxStrcmp (buf, _T("3E+01")) != 0)
2023     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3E+01"));
2024 }
2025
2026 static void
2027 rfg2 (void)
2028 {
2029   int prec;
2030   wxChar buf[100];
2031   wxString test_format;
2032
2033   prec = 0;
2034   wxSprintf (buf, _T("%.*g"), prec, 3.3);
2035   if (wxStrcmp (buf, _T("3")) != 0)
2036     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
2037   prec = 0;
2038   wxSprintf (buf, _T("%.*G"), prec, 3.3);
2039   if (wxStrcmp (buf, _T("3")) != 0)
2040     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
2041   prec = 0;
2042   wxSprintf (buf, _T("%7.*G"), prec, 3.33);
2043   if (wxStrcmp (buf, _T("      3")) != 0)
2044     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("      3"));
2045   prec = 3;
2046   test_format = _T("%04.*o");
2047   wxSprintf (buf, test_format.c_str(), prec, 33);
2048   if (wxStrcmp (buf, _T(" 041")) != 0)
2049     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
2050   prec = 7;
2051   test_format = _T("%09.*u");
2052   wxSprintf (buf, test_format.c_str(), prec, 33);
2053   if (wxStrcmp (buf, _T("  0000033")) != 0)
2054     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("  0000033"));
2055   prec = 3;
2056   test_format = _T("%04.*x");
2057   wxSprintf (buf, test_format.c_str(), prec, 33);
2058   if (wxStrcmp (buf, _T(" 021")) != 0)
2059     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2060   prec = 3;
2061   test_format = _T("%04.*X");
2062   wxSprintf (buf, test_format.c_str(), prec, 33);
2063   if (wxStrcmp (buf, _T(" 021")) != 0)
2064     wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2065 }
2066
2067 #endif // TEST_PRINTF
2068
2069 // ----------------------------------------------------------------------------
2070 // registry and related stuff
2071 // ----------------------------------------------------------------------------
2072
2073 // this is for MSW only
2074 #ifndef __WXMSW__
2075     #undef TEST_REGCONF
2076     #undef TEST_REGISTRY
2077 #endif
2078
2079 #ifdef TEST_REGCONF
2080
2081 #include "wx/confbase.h"
2082 #include "wx/msw/regconf.h"
2083
2084 #if 0
2085 static void TestRegConfWrite()
2086 {
2087     wxConfig *config = new wxConfig(_T("myapp"));
2088     config->SetPath(_T("/group1"));
2089     config->Write(_T("entry1"), _T("foo"));
2090     config->SetPath(_T("/group2"));
2091     config->Write(_T("entry1"), _T("bar"));
2092 }
2093 #endif
2094
2095 static void TestRegConfRead()
2096 {
2097     wxRegConfig *config = new wxRegConfig(_T("myapp"));
2098
2099     wxString str;
2100     long dummy;
2101     config->SetPath(_T("/"));
2102     wxPuts(_T("Enumerating / subgroups:"));
2103     bool bCont = config->GetFirstGroup(str, dummy);
2104     while(bCont)
2105     {
2106         wxPuts(str);
2107         bCont = config->GetNextGroup(str, dummy);
2108     }
2109 }
2110
2111 #endif // TEST_REGCONF
2112
2113 #ifdef TEST_REGISTRY
2114
2115 #include "wx/msw/registry.h"
2116
2117 // I chose this one because I liked its name, but it probably only exists under
2118 // NT
2119 static const wxChar *TESTKEY =
2120     _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2121
2122 static void TestRegistryRead()
2123 {
2124     wxPuts(_T("*** testing registry reading ***"));
2125
2126     wxRegKey key(TESTKEY);
2127     wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
2128     if ( !key.Open() )
2129     {
2130         wxPuts(_T("ERROR: test key can't be opened, aborting test."));
2131
2132         return;
2133     }
2134
2135     size_t nSubKeys, nValues;
2136     if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
2137     {
2138         wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
2139     }
2140
2141     wxPrintf(_T("Enumerating values:\n"));
2142
2143     long dummy;
2144     wxString value;
2145     bool cont = key.GetFirstValue(value, dummy);
2146     while ( cont )
2147     {
2148         wxPrintf(_T("Value '%s': type "), value.c_str());
2149         switch ( key.GetValueType(value) )
2150         {
2151             case wxRegKey::Type_None:   wxPrintf(_T("ERROR (none)")); break;
2152             case wxRegKey::Type_String: wxPrintf(_T("SZ")); break;
2153             case wxRegKey::Type_Expand_String: wxPrintf(_T("EXPAND_SZ")); break;
2154             case wxRegKey::Type_Binary: wxPrintf(_T("BINARY")); break;
2155             case wxRegKey::Type_Dword: wxPrintf(_T("DWORD")); break;
2156             case wxRegKey::Type_Multi_String: wxPrintf(_T("MULTI_SZ")); break;
2157             default: wxPrintf(_T("other (unknown)")); break;
2158         }
2159
2160         wxPrintf(_T(", value = "));
2161         if ( key.IsNumericValue(value) )
2162         {
2163             long val;
2164             key.QueryValue(value, &val);
2165             wxPrintf(_T("%ld"), val);
2166         }
2167         else // string
2168         {
2169             wxString val;
2170             key.QueryValue(value, val);
2171             wxPrintf(_T("'%s'"), val.c_str());
2172
2173             key.QueryRawValue(value, val);
2174             wxPrintf(_T(" (raw value '%s')"), val.c_str());
2175         }
2176
2177         wxPutchar('\n');
2178
2179         cont = key.GetNextValue(value, dummy);
2180     }
2181 }
2182
2183 static void TestRegistryAssociation()
2184 {
2185     /*
2186        The second call to deleteself genertaes an error message, with a
2187        messagebox saying .flo is crucial to system operation, while the .ddf
2188        call also fails, but with no error message
2189     */
2190
2191     wxRegKey key;
2192
2193     key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2194     key.Create();
2195     key = _T("ddxf_auto_file") ;
2196     key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2197     key.Create();
2198     key = _T("ddxf_auto_file") ;
2199     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2200     key.Create();
2201     key = _T("program,0") ;
2202     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2203     key.Create();
2204     key = _T("program \"%1\"") ;
2205
2206     key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2207     key.DeleteSelf();
2208     key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2209     key.DeleteSelf();
2210     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2211     key.DeleteSelf();
2212     key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2213     key.DeleteSelf();
2214 }
2215
2216 #endif // TEST_REGISTRY
2217
2218 // ----------------------------------------------------------------------------
2219 // scope guard
2220 // ----------------------------------------------------------------------------
2221
2222 #ifdef TEST_SCOPEGUARD
2223
2224 #include "wx/scopeguard.h"
2225
2226 static void function0() { puts("function0()"); }
2227 static void function1(int n) { printf("function1(%d)\n", n); }
2228 static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
2229
2230 struct Object
2231 {
2232     void method0() { printf("method0()\n"); }
2233     void method1(int n) { printf("method1(%d)\n", n); }
2234     void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
2235 };
2236
2237 static void TestScopeGuard()
2238 {
2239     wxON_BLOCK_EXIT0(function0);
2240     wxON_BLOCK_EXIT1(function1, 17);
2241     wxON_BLOCK_EXIT2(function2, 3.14, 'p');
2242
2243     Object obj;
2244     wxON_BLOCK_EXIT_OBJ0(obj, Object::method0);
2245     wxON_BLOCK_EXIT_OBJ1(obj, Object::method1, 7);
2246     wxON_BLOCK_EXIT_OBJ2(obj, Object::method2, 2.71, 'e');
2247
2248     wxScopeGuard dismissed = wxMakeGuard(function0);
2249     dismissed.Dismiss();
2250 }
2251
2252 #endif
2253
2254 // ----------------------------------------------------------------------------
2255 // sockets
2256 // ----------------------------------------------------------------------------
2257
2258 #ifdef TEST_SOCKETS
2259
2260 #include "wx/socket.h"
2261 #include "wx/protocol/protocol.h"
2262 #include "wx/protocol/http.h"
2263
2264 static void TestSocketServer()
2265 {
2266     wxPuts(_T("*** Testing wxSocketServer ***\n"));
2267
2268     static const int PORT = 3000;
2269
2270     wxIPV4address addr;
2271     addr.Service(PORT);
2272
2273     wxSocketServer *server = new wxSocketServer(addr);
2274     if ( !server->Ok() )
2275     {
2276         wxPuts(_T("ERROR: failed to bind"));
2277
2278         return;
2279     }
2280
2281     bool quit = false;
2282     while ( !quit )
2283     {
2284         wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
2285
2286         wxSocketBase *socket = server->Accept();
2287         if ( !socket )
2288         {
2289             wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
2290             break;
2291         }
2292
2293         wxPuts(_T("Server: got a client."));
2294
2295         server->SetTimeout(60); // 1 min
2296
2297         bool close = false;
2298         while ( !close && socket->IsConnected() )
2299         {
2300             wxString s;
2301             wxChar ch = _T('\0');
2302             for ( ;; )
2303             {
2304                 if ( socket->Read(&ch, sizeof(ch)).Error() )
2305                 {
2306                     // don't log error if the client just close the connection
2307                     if ( socket->IsConnected() )
2308                     {
2309                         wxPuts(_T("ERROR: in wxSocket::Read."));
2310                     }
2311
2312                     break;
2313                 }
2314
2315                 if ( ch == '\r' )
2316                     continue;
2317
2318                 if ( ch == '\n' )
2319                     break;
2320
2321                 s += ch;
2322             }
2323
2324             if ( ch != '\n' )
2325             {
2326                 break;
2327             }
2328
2329             wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
2330             if ( s == _T("close") )
2331             {
2332                 wxPuts(_T("Closing connection"));
2333
2334                 close = true;
2335             }
2336             else if ( s == _T("quit") )
2337             {
2338                 close =
2339                 quit = true;
2340
2341                 wxPuts(_T("Shutting down the server"));
2342             }
2343             else // not a special command
2344             {
2345                 socket->Write(s.MakeUpper().c_str(), s.length());
2346                 socket->Write("\r\n", 2);
2347                 wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
2348             }
2349         }
2350
2351         if ( !close )
2352         {
2353             wxPuts(_T("Server: lost a client unexpectedly."));
2354         }
2355
2356         socket->Destroy();
2357     }
2358
2359     // same as "delete server" but is consistent with GUI programs
2360     server->Destroy();
2361 }
2362
2363 static void TestSocketClient()
2364 {
2365     wxPuts(_T("*** Testing wxSocketClient ***\n"));
2366
2367     static const wxChar *hostname = _T("www.wxwidgets.org");
2368
2369     wxIPV4address addr;
2370     addr.Hostname(hostname);
2371     addr.Service(80);
2372
2373     wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
2374
2375     wxSocketClient client;
2376     if ( !client.Connect(addr) )
2377     {
2378         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2379     }
2380     else
2381     {
2382         wxPrintf(_T("--- Connected to %s:%u...\n"),
2383                addr.Hostname().c_str(), addr.Service());
2384
2385         wxChar buf[8192];
2386
2387         // could use simply "GET" here I suppose
2388         wxString cmdGet =
2389             wxString::Format(_T("GET http://%s/\r\n"), hostname);
2390         client.Write(cmdGet, cmdGet.length());
2391         wxPrintf(_T("--- Sent command '%s' to the server\n"),
2392                MakePrintable(cmdGet).c_str());
2393         client.Read(buf, WXSIZEOF(buf));
2394         wxPrintf(_T("--- Server replied:\n%s"), buf);
2395     }
2396 }
2397
2398 #endif // TEST_SOCKETS
2399
2400 // ----------------------------------------------------------------------------
2401 // FTP
2402 // ----------------------------------------------------------------------------
2403
2404 #ifdef TEST_FTP
2405
2406 #include "wx/protocol/ftp.h"
2407
2408 #define FTP_ANONYMOUS
2409
2410 static wxFTP *ftp;
2411
2412 #ifdef FTP_ANONYMOUS
2413     static const wxChar *directory = _T("/pub");
2414     static const wxChar *filename = _T("welcome.msg");
2415 #else
2416     static const wxChar *directory = _T("/etc");
2417     static const wxChar *filename = _T("issue");
2418 #endif
2419
2420 static bool TestFtpConnect()
2421 {
2422     wxPuts(_T("*** Testing FTP connect ***"));
2423
2424     // wxFTP cannot be a static variable as its ctor needs to access
2425     // wxWidgets internals after it has been initialized
2426     ftp = new wxFTP;
2427
2428 #ifdef FTP_ANONYMOUS
2429     static const wxChar *hostname = _T("ftp->wxwidgets.org");
2430
2431     wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
2432 #else // !FTP_ANONYMOUS
2433     static const wxChar *hostname = "localhost";
2434
2435     wxChar user[256];
2436     wxFgets(user, WXSIZEOF(user), stdin);
2437     user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
2438     ftp->SetUser(user);
2439
2440     wxChar password[256];
2441     wxPrintf(_T("Password for %s: "), password);
2442     wxFgets(password, WXSIZEOF(password), stdin);
2443     password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
2444     ftp->SetPassword(password);
2445
2446     wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
2447 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2448
2449     if ( !ftp->Connect(hostname) )
2450     {
2451         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2452
2453         return false;
2454     }
2455     else
2456     {
2457         wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
2458                  hostname, ftp->Pwd().c_str());
2459         ftp->Close();
2460     }
2461
2462     return true;
2463 }
2464
2465 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2466 static void TestFtpWuFtpd()
2467 {
2468     wxFTP ftp;
2469     static const wxChar *hostname = _T("ftp.eudora.com");
2470     if ( !ftp.Connect(hostname) )
2471     {
2472         wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2473     }
2474     else
2475     {
2476         static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
2477         wxInputStream *in = ftp.GetInputStream(filename);
2478         if ( !in )
2479         {
2480             wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
2481         }
2482         else
2483         {
2484             size_t size = in->GetSize();
2485             wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
2486
2487             wxChar *data = new wxChar[size];
2488             if ( !in->Read(data, size) )
2489             {
2490                 wxPuts(_T("ERROR: read error"));
2491             }
2492             else
2493             {
2494                 wxPrintf(_T("Successfully retrieved the file.\n"));
2495             }
2496
2497             delete [] data;
2498             delete in;
2499         }
2500     }
2501 }
2502
2503 static void TestFtpList()
2504 {
2505     wxPuts(_T("*** Testing wxFTP file listing ***\n"));
2506
2507     // test CWD
2508     if ( !ftp->ChDir(directory) )
2509     {
2510         wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
2511     }
2512
2513     wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2514
2515     // test NLIST and LIST
2516     wxArrayString files;
2517     if ( !ftp->GetFilesList(files) )
2518     {
2519         wxPuts(_T("ERROR: failed to get NLIST of files"));
2520     }
2521     else
2522     {
2523         wxPrintf(_T("Brief list of files under '%s':\n"), ftp->Pwd().c_str());
2524         size_t count = files.GetCount();
2525         for ( size_t n = 0; n < count; n++ )
2526         {
2527             wxPrintf(_T("\t%s\n"), files[n].c_str());
2528         }
2529         wxPuts(_T("End of the file list"));
2530     }
2531
2532     if ( !ftp->GetDirList(files) )
2533     {
2534         wxPuts(_T("ERROR: failed to get LIST of files"));
2535     }
2536     else
2537     {
2538         wxPrintf(_T("Detailed list of files under '%s':\n"), ftp->Pwd().c_str());
2539         size_t count = files.GetCount();
2540         for ( size_t n = 0; n < count; n++ )
2541         {
2542             wxPrintf(_T("\t%s\n"), files[n].c_str());
2543         }
2544         wxPuts(_T("End of the file list"));
2545     }
2546
2547     if ( !ftp->ChDir(_T("..")) )
2548     {
2549         wxPuts(_T("ERROR: failed to cd to .."));
2550     }
2551
2552     wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2553 }
2554
2555 static void TestFtpDownload()
2556 {
2557     wxPuts(_T("*** Testing wxFTP download ***\n"));
2558
2559     // test RETR
2560     wxInputStream *in = ftp->GetInputStream(filename);
2561     if ( !in )
2562     {
2563         wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
2564     }
2565     else
2566     {
2567         size_t size = in->GetSize();
2568         wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
2569         fflush(stdout);
2570
2571         wxChar *data = new wxChar[size];
2572         if ( !in->Read(data, size) )
2573         {
2574             wxPuts(_T("ERROR: read error"));
2575         }
2576         else
2577         {
2578             wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
2579         }
2580
2581         delete [] data;
2582         delete in;
2583     }
2584 }
2585
2586 static void TestFtpFileSize()
2587 {
2588     wxPuts(_T("*** Testing FTP SIZE command ***"));
2589
2590     if ( !ftp->ChDir(directory) )
2591     {
2592         wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
2593     }
2594
2595     wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2596
2597     if ( ftp->FileExists(filename) )
2598     {
2599         int size = ftp->GetFileSize(filename);
2600         if ( size == -1 )
2601             wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
2602         else
2603             wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
2604     }
2605     else
2606     {
2607         wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
2608     }
2609 }
2610
2611 static void TestFtpMisc()
2612 {
2613     wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
2614
2615     if ( ftp->SendCommand(_T("STAT")) != '2' )
2616     {
2617         wxPuts(_T("ERROR: STAT failed"));
2618     }
2619     else
2620     {
2621         wxPrintf(_T("STAT returned:\n\n%s\n"), ftp->GetLastResult().c_str());
2622     }
2623
2624     if ( ftp->SendCommand(_T("HELP SITE")) != '2' )
2625     {
2626         wxPuts(_T("ERROR: HELP SITE failed"));
2627     }
2628     else
2629     {
2630         wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
2631                ftp->GetLastResult().c_str());
2632     }
2633 }
2634
2635 static void TestFtpInteractive()
2636 {
2637     wxPuts(_T("\n*** Interactive wxFTP test ***"));
2638
2639     wxChar buf[128];
2640
2641     for ( ;; )
2642     {
2643         wxPrintf(_T("Enter FTP command: "));
2644         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
2645             break;
2646
2647         // kill the last '\n'
2648         buf[wxStrlen(buf) - 1] = 0;
2649
2650         // special handling of LIST and NLST as they require data connection
2651         wxString start(buf, 4);
2652         start.MakeUpper();
2653         if ( start == _T("LIST") || start == _T("NLST") )
2654         {
2655             wxString wildcard;
2656             if ( wxStrlen(buf) > 4 )
2657                 wildcard = buf + 5;
2658
2659             wxArrayString files;
2660             if ( !ftp->GetList(files, wildcard, start == _T("LIST")) )
2661             {
2662                 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
2663             }
2664             else
2665             {
2666                 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
2667                        start.c_str(), wildcard.c_str(), ftp->Pwd().c_str());
2668                 size_t count = files.GetCount();
2669                 for ( size_t n = 0; n < count; n++ )
2670                 {
2671                     wxPrintf(_T("\t%s\n"), files[n].c_str());
2672                 }
2673                 wxPuts(_T("--- End of the file list"));
2674             }
2675         }
2676         else // !list
2677         {
2678             wxChar ch = ftp->SendCommand(buf);
2679             wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
2680             if ( ch )
2681             {
2682                 wxPrintf(_T(" (return code %c)"), ch);
2683             }
2684
2685             wxPrintf(_T(", server reply:\n%s\n\n"), ftp->GetLastResult().c_str());
2686         }
2687     }
2688
2689     wxPuts(_T("\n*** done ***"));
2690 }
2691
2692 static void TestFtpUpload()
2693 {
2694     wxPuts(_T("*** Testing wxFTP uploading ***\n"));
2695
2696     // upload a file
2697     static const wxChar *file1 = _T("test1");
2698     static const wxChar *file2 = _T("test2");
2699     wxOutputStream *out = ftp->GetOutputStream(file1);
2700     if ( out )
2701     {
2702         wxPrintf(_T("--- Uploading to %s ---\n"), file1);
2703         out->Write("First hello", 11);
2704         delete out;
2705     }
2706
2707     // send a command to check the remote file
2708     if ( ftp->SendCommand(wxString(_T("STAT ")) + file1) != '2' )
2709     {
2710         wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
2711     }
2712     else
2713     {
2714         wxPrintf(_T("STAT %s returned:\n\n%s\n"),
2715                file1, ftp->GetLastResult().c_str());
2716     }
2717
2718     out = ftp->GetOutputStream(file2);
2719     if ( out )
2720     {
2721         wxPrintf(_T("--- Uploading to %s ---\n"), file1);
2722         out->Write("Second hello", 12);
2723         delete out;
2724     }
2725 }
2726
2727 #endif // TEST_FTP
2728
2729 // ----------------------------------------------------------------------------
2730 // stack backtrace
2731 // ----------------------------------------------------------------------------
2732
2733 #ifdef TEST_STACKWALKER
2734
2735 #if wxUSE_STACKWALKER
2736
2737 #include "wx/stackwalk.h"
2738
2739 class StackDump : public wxStackWalker
2740 {
2741 public:
2742     StackDump(const char *argv0)
2743         : wxStackWalker(argv0)
2744     {
2745     }
2746
2747     virtual void Walk(size_t skip = 1)
2748     {
2749         wxPuts(_T("Stack dump:"));
2750
2751         wxStackWalker::Walk(skip);
2752     }
2753
2754 protected:
2755     virtual void OnStackFrame(const wxStackFrame& frame)
2756     {
2757         printf("[%2d] ", (int) frame.GetLevel());
2758
2759         wxString name = frame.GetName();
2760         if ( !name.empty() )
2761         {
2762             printf("%-20.40s", (const char*)name.mb_str());
2763         }
2764         else
2765         {
2766             printf("0x%08lx", (unsigned long)frame.GetAddress());
2767         }
2768
2769         if ( frame.HasSourceLocation() )
2770         {
2771             printf("\t%s:%d",
2772                    (const char*)frame.GetFileName().mb_str(),
2773                    (int)frame.GetLine());
2774         }
2775
2776         puts("");
2777
2778         wxString type, val;
2779         for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
2780         {
2781             printf("\t%s %s = %s\n", (const char*)type.mb_str(),
2782                                      (const char*)name.mb_str(),
2783                                      (const char*)val.mb_str());
2784         }
2785     }
2786 };
2787
2788 static void TestStackWalk(const char *argv0)
2789 {
2790     wxPuts(_T("*** Testing wxStackWalker ***\n"));
2791
2792     StackDump dump(argv0);
2793     dump.Walk();
2794 }
2795
2796 #endif // wxUSE_STACKWALKER
2797
2798 #endif // TEST_STACKWALKER
2799
2800 // ----------------------------------------------------------------------------
2801 // standard paths
2802 // ----------------------------------------------------------------------------
2803
2804 #ifdef TEST_STDPATHS
2805
2806 #include "wx/stdpaths.h"
2807 #include "wx/wxchar.h"      // wxPrintf
2808
2809 static void TestStandardPaths()
2810 {
2811     wxPuts(_T("*** Testing wxStandardPaths ***\n"));
2812
2813     wxTheApp->SetAppName(_T("console"));
2814
2815     wxStandardPathsBase& stdp = wxStandardPaths::Get();
2816     wxPrintf(_T("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
2817     wxPrintf(_T("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
2818     wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
2819     wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
2820     wxPrintf(_T("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
2821     wxPrintf(_T("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
2822     wxPrintf(_T("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
2823     wxPrintf(_T("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
2824     wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
2825     wxPrintf(_T("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
2826     wxPrintf(_T("Localized res. dir:\t%s\n"),
2827              stdp.GetLocalizedResourcesDir(_T("fr")).c_str());
2828     wxPrintf(_T("Message catalogs dir:\t%s\n"),
2829              stdp.GetLocalizedResourcesDir
2830                   (
2831                     _T("fr"),
2832                     wxStandardPaths::ResourceCat_Messages
2833                   ).c_str());
2834 }
2835
2836 #endif // TEST_STDPATHS
2837
2838 // ----------------------------------------------------------------------------
2839 // streams
2840 // ----------------------------------------------------------------------------
2841
2842 #ifdef TEST_STREAMS
2843
2844 #include "wx/wfstream.h"
2845 #include "wx/mstream.h"
2846
2847 static void TestFileStream()
2848 {
2849     wxPuts(_T("*** Testing wxFileInputStream ***"));
2850
2851     static const wxString filename = _T("testdata.fs");
2852     {
2853         wxFileOutputStream fsOut(filename);
2854         fsOut.Write("foo", 3);
2855     }
2856
2857     {
2858         wxFileInputStream fsIn(filename);
2859         wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
2860         while ( !fsIn.Eof() )
2861         {
2862             wxPutchar(fsIn.GetC());
2863         }
2864     }
2865
2866     if ( !wxRemoveFile(filename) )
2867     {
2868         wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
2869     }
2870
2871     wxPuts(_T("\n*** wxFileInputStream test done ***"));
2872 }
2873
2874 static void TestMemoryStream()
2875 {
2876     wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
2877
2878     wxMemoryOutputStream memOutStream;
2879     wxPrintf(_T("Initially out stream offset: %lu\n"),
2880              (unsigned long)memOutStream.TellO());
2881
2882     for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
2883     {
2884         memOutStream.PutC(*p);
2885     }
2886
2887     wxPrintf(_T("Final out stream offset: %lu\n"),
2888              (unsigned long)memOutStream.TellO());
2889
2890     wxPuts(_T("*** Testing wxMemoryInputStream ***"));
2891
2892     wxChar buf[1024];
2893     size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
2894
2895     wxMemoryInputStream memInpStream(buf, len);
2896     wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
2897     while ( !memInpStream.Eof() )
2898     {
2899         wxPutchar(memInpStream.GetC());
2900     }
2901
2902     wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
2903 }
2904
2905 #endif // TEST_STREAMS
2906
2907 // ----------------------------------------------------------------------------
2908 // timers
2909 // ----------------------------------------------------------------------------
2910
2911 #ifdef TEST_TIMER
2912
2913 #include "wx/stopwatch.h"
2914 #include "wx/utils.h"
2915
2916 static void TestStopWatch()
2917 {
2918     wxPuts(_T("*** Testing wxStopWatch ***\n"));
2919
2920     wxStopWatch sw;
2921     sw.Pause();
2922     wxPrintf(_T("Initially paused, after 2 seconds time is..."));
2923     fflush(stdout);
2924     wxSleep(2);
2925     wxPrintf(_T("\t%ldms\n"), sw.Time());
2926
2927     wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
2928     fflush(stdout);
2929     sw.Resume();
2930     wxSleep(3);
2931     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2932
2933     sw.Pause();
2934     wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
2935     fflush(stdout);
2936     wxSleep(2);
2937     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2938
2939     sw.Resume();
2940     wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
2941     fflush(stdout);
2942     wxSleep(2);
2943     wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
2944
2945     wxStopWatch sw2;
2946     wxPuts(_T("\nChecking for 'backwards clock' bug..."));
2947     for ( size_t n = 0; n < 70; n++ )
2948     {
2949         sw2.Start();
2950
2951         for ( size_t m = 0; m < 100000; m++ )
2952         {
2953             if ( sw.Time() < 0 || sw2.Time() < 0 )
2954             {
2955                 wxPuts(_T("\ntime is negative - ERROR!"));
2956             }
2957         }
2958
2959         wxPutchar('.');
2960         fflush(stdout);
2961     }
2962
2963     wxPuts(_T(", ok."));
2964 }
2965
2966 #include "wx/timer.h"
2967 #include "wx/evtloop.h"
2968
2969 void TestTimer()
2970 {
2971     wxPuts(_T("*** Testing wxTimer ***\n"));
2972
2973     class MyTimer : public wxTimer
2974     {
2975     public:
2976         MyTimer() : wxTimer() { m_num = 0; }
2977
2978         virtual void Notify()
2979         {
2980             wxPrintf(_T("%d"), m_num++);
2981             fflush(stdout);
2982
2983             if ( m_num == 10 )
2984             {
2985                 wxPrintf(_T("... exiting the event loop"));
2986                 Stop();
2987
2988                 wxEventLoop::GetActive()->Exit(0);
2989                 wxPuts(_T(", ok."));
2990             }
2991
2992             fflush(stdout);
2993         }
2994
2995     private:
2996         int m_num;
2997     };
2998
2999     wxEventLoop loop;
3000
3001     wxTimer timer1;
3002     timer1.Start(100, true /* one shot */);
3003     timer1.Stop();
3004     timer1.Start(100, true /* one shot */);
3005
3006     MyTimer timer;
3007     timer.Start(500);
3008
3009     loop.Run();
3010 }
3011
3012 #endif // TEST_TIMER
3013
3014 // ----------------------------------------------------------------------------
3015 // vCard support
3016 // ----------------------------------------------------------------------------
3017
3018 #ifdef TEST_VCARD
3019
3020 #include "wx/vcard.h"
3021
3022 static void DumpVObject(size_t level, const wxVCardObject& vcard)
3023 {
3024     void *cookie;
3025     wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3026     while ( vcObj )
3027     {
3028         wxPrintf(_T("%s%s"),
3029                wxString(_T('\t'), level).c_str(),
3030                vcObj->GetName().c_str());
3031
3032         wxString value;
3033         switch ( vcObj->GetType() )
3034         {
3035             case wxVCardObject::String:
3036             case wxVCardObject::UString:
3037                 {
3038                     wxString val;
3039                     vcObj->GetValue(&val);
3040                     value << _T('"') << val << _T('"');
3041                 }
3042                 break;
3043
3044             case wxVCardObject::Int:
3045                 {
3046                     unsigned int i;
3047                     vcObj->GetValue(&i);
3048                     value.Printf(_T("%u"), i);
3049                 }
3050                 break;
3051
3052             case wxVCardObject::Long:
3053                 {
3054                     unsigned long l;
3055                     vcObj->GetValue(&l);
3056                     value.Printf(_T("%lu"), l);
3057                 }
3058                 break;
3059
3060             case wxVCardObject::None:
3061                 break;
3062
3063             case wxVCardObject::Object:
3064                 value = _T("<node>");
3065                 break;
3066
3067             default:
3068                 value = _T("<unknown value type>");
3069         }
3070
3071         if ( !!value )
3072             wxPrintf(_T(" = %s"), value.c_str());
3073         wxPutchar('\n');
3074
3075         DumpVObject(level + 1, *vcObj);
3076
3077         delete vcObj;
3078         vcObj = vcard.GetNextProp(&cookie);
3079     }
3080 }
3081
3082 static void DumpVCardAddresses(const wxVCard& vcard)
3083 {
3084     wxPuts(_T("\nShowing all addresses from vCard:\n"));
3085
3086     size_t nAdr = 0;
3087     void *cookie;
3088     wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3089     while ( addr )
3090     {
3091         wxString flagsStr;
3092         int flags = addr->GetFlags();
3093         if ( flags & wxVCardAddress::Domestic )
3094         {
3095             flagsStr << _T("domestic ");
3096         }
3097         if ( flags & wxVCardAddress::Intl )
3098         {
3099             flagsStr << _T("international ");
3100         }
3101         if ( flags & wxVCardAddress::Postal )
3102         {
3103             flagsStr << _T("postal ");
3104         }
3105         if ( flags & wxVCardAddress::Parcel )
3106         {
3107             flagsStr << _T("parcel ");
3108         }
3109         if ( flags & wxVCardAddress::Home )
3110         {
3111             flagsStr << _T("home ");
3112         }
3113         if ( flags & wxVCardAddress::Work )
3114         {
3115             flagsStr << _T("work ");
3116         }
3117
3118         wxPrintf(_T("Address %u:\n")
3119                "\tflags = %s\n"
3120                "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3121                ++nAdr,
3122                flagsStr.c_str(),
3123                addr->GetPostOffice().c_str(),
3124                addr->GetExtAddress().c_str(),
3125                addr->GetStreet().c_str(),
3126                addr->GetLocality().c_str(),
3127                addr->GetRegion().c_str(),
3128                addr->GetPostalCode().c_str(),
3129                addr->GetCountry().c_str()
3130                );
3131
3132         delete addr;
3133         addr = vcard.GetNextAddress(&cookie);
3134     }
3135 }
3136
3137 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
3138 {
3139     wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
3140
3141     size_t nPhone = 0;
3142     void *cookie;
3143     wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
3144     while ( phone )
3145     {
3146         wxString flagsStr;
3147         int flags = phone->GetFlags();
3148         if ( flags & wxVCardPhoneNumber::Voice )
3149         {
3150             flagsStr << _T("voice ");
3151         }
3152         if ( flags & wxVCardPhoneNumber::Fax )
3153         {
3154             flagsStr << _T("fax ");
3155         }
3156         if ( flags & wxVCardPhoneNumber::Cellular )
3157         {
3158             flagsStr << _T("cellular ");
3159         }
3160         if ( flags & wxVCardPhoneNumber::Modem )
3161         {
3162             flagsStr << _T("modem ");
3163         }
3164         if ( flags & wxVCardPhoneNumber::Home )
3165         {
3166             flagsStr << _T("home ");
3167         }
3168         if ( flags & wxVCardPhoneNumber::Work )
3169         {
3170             flagsStr << _T("work ");
3171         }
3172
3173         wxPrintf(_T("Phone number %u:\n")
3174                "\tflags = %s\n"
3175                "\tvalue = %s\n",
3176                ++nPhone,
3177                flagsStr.c_str(),
3178                phone->GetNumber().c_str()
3179                );
3180
3181         delete phone;
3182         phone = vcard.GetNextPhoneNumber(&cookie);
3183     }
3184 }
3185
3186 static void TestVCardRead()
3187 {
3188     wxPuts(_T("*** Testing wxVCard reading ***\n"));
3189
3190     wxVCard vcard(_T("vcard.vcf"));
3191     if ( !vcard.IsOk() )
3192     {
3193         wxPuts(_T("ERROR: couldn't load vCard."));
3194     }
3195     else
3196     {
3197         // read individual vCard properties
3198         wxVCardObject *vcObj = vcard.GetProperty("FN");
3199         wxString value;
3200         if ( vcObj )
3201         {
3202             vcObj->GetValue(&value);
3203             delete vcObj;
3204         }
3205         else
3206         {
3207             value = _T("<none>");
3208         }
3209
3210         wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
3211
3212
3213         if ( !vcard.GetFullName(&value) )
3214         {
3215             value = _T("<none>");
3216         }
3217
3218         wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
3219
3220         // now show how to deal with multiply occurring properties
3221         DumpVCardAddresses(vcard);
3222         DumpVCardPhoneNumbers(vcard);
3223
3224         // and finally show all
3225         wxPuts(_T("\nNow dumping the entire vCard:\n")
3226              "-----------------------------\n");
3227
3228         DumpVObject(0, vcard);
3229     }
3230 }
3231
3232 static void TestVCardWrite()
3233 {
3234     wxPuts(_T("*** Testing wxVCard writing ***\n"));
3235
3236     wxVCard vcard;
3237     if ( !vcard.IsOk() )
3238     {
3239         wxPuts(_T("ERROR: couldn't create vCard."));
3240     }
3241     else
3242     {
3243         // set some fields
3244         vcard.SetName("Zeitlin", "Vadim");
3245         vcard.SetFullName("Vadim Zeitlin");
3246         vcard.SetOrganization("wxWidgets", "R&D");
3247
3248         // just dump the vCard back
3249         wxPuts(_T("Entire vCard follows:\n"));
3250         wxPuts(vcard.Write());
3251     }
3252 }
3253
3254 #endif // TEST_VCARD
3255
3256 // ----------------------------------------------------------------------------
3257 // wxVolume tests
3258 // ----------------------------------------------------------------------------
3259
3260 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
3261     #undef TEST_VOLUME
3262 #endif
3263
3264 #ifdef TEST_VOLUME
3265
3266 #include "wx/volume.h"
3267
3268 static const wxChar *volumeKinds[] =
3269 {
3270     _T("floppy"),
3271     _T("hard disk"),
3272     _T("CD-ROM"),
3273     _T("DVD-ROM"),
3274     _T("network volume"),
3275     _T("other volume"),
3276 };
3277
3278 static void TestFSVolume()
3279 {
3280     wxPuts(_T("*** Testing wxFSVolume class ***"));
3281
3282     wxArrayString volumes = wxFSVolume::GetVolumes();
3283     size_t count = volumes.GetCount();
3284
3285     if ( !count )
3286     {
3287         wxPuts(_T("ERROR: no mounted volumes?"));
3288         return;
3289     }
3290
3291     wxPrintf(_T("%u mounted volumes found:\n"), count);
3292
3293     for ( size_t n = 0; n < count; n++ )
3294     {
3295         wxFSVolume vol(volumes[n]);
3296         if ( !vol.IsOk() )
3297         {
3298             wxPuts(_T("ERROR: couldn't create volume"));
3299             continue;
3300         }
3301
3302         wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3303                  n + 1,
3304                  vol.GetDisplayName().c_str(),
3305                  vol.GetName().c_str(),
3306                  volumeKinds[vol.GetKind()],
3307                  vol.IsWritable() ? _T("rw") : _T("ro"),
3308                  vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3309                                                      : _T("fixed"));
3310     }
3311 }
3312
3313 #endif // TEST_VOLUME
3314
3315 // ----------------------------------------------------------------------------
3316 // wide char and Unicode support
3317 // ----------------------------------------------------------------------------
3318
3319 #ifdef TEST_WCHAR
3320
3321 #include "wx/strconv.h"
3322 #include "wx/fontenc.h"
3323 #include "wx/encconv.h"
3324 #include "wx/buffer.h"
3325
3326 static const unsigned char utf8koi8r[] =
3327 {
3328     208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3329     208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3330     176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3331     208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3332     181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3333     208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3334     178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3335 };
3336
3337 static const unsigned char utf8iso8859_1[] =
3338 {
3339     0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3340     0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3341     0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3342     0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3343     0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3344 };
3345
3346 static const unsigned char utf8Invalid[] =
3347 {
3348     0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3349     0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3350     0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3351     0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3352     0x6c, 0x61, 0x79, 0
3353 };
3354
3355 static const struct Utf8Data
3356 {
3357     const unsigned char *text;
3358     size_t len;
3359     const wxChar *charset;
3360     wxFontEncoding encoding;
3361 } utf8data[] =
3362 {
3363     { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3364     { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3365     { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3366 };
3367
3368 static void TestUtf8()
3369 {
3370     wxPuts(_T("*** Testing UTF8 support ***\n"));
3371
3372     char buf[1024];
3373     wchar_t wbuf[1024];
3374
3375     for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
3376     {
3377         const Utf8Data& u8d = utf8data[n];
3378         if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3379                               WXSIZEOF(wbuf)) == (size_t)-1 )
3380         {
3381             wxPuts(_T("ERROR: UTF-8 decoding failed."));
3382         }
3383         else
3384         {
3385             wxCSConv conv(u8d.charset);
3386             if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3387             {
3388                 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3389             }
3390             else
3391             {
3392                 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3393             }
3394         }
3395
3396         wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
3397         if ( s.empty() )
3398             s = _T("<< conversion failed >>");
3399         wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3400
3401     }
3402
3403     wxPuts(wxEmptyString);
3404 }
3405
3406 static void TestEncodingConverter()
3407 {
3408     wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3409
3410     // using wxEncodingConverter should give the same result as above
3411     char buf[1024];
3412     wchar_t wbuf[1024];
3413     if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
3414                           WXSIZEOF(utf8koi8r)) == (size_t)-1 )
3415     {
3416         wxPuts(_T("ERROR: UTF-8 decoding failed."));
3417     }
3418     else
3419     {
3420         wxEncodingConverter ec;
3421         ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3422         ec.Convert(wbuf, buf);
3423         wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
3424     }
3425
3426     wxPuts(wxEmptyString);
3427 }
3428
3429 #endif // TEST_WCHAR
3430
3431 // ----------------------------------------------------------------------------
3432 // ZIP stream
3433 // ----------------------------------------------------------------------------
3434
3435 #ifdef TEST_ZIP
3436
3437 #include "wx/filesys.h"
3438 #include "wx/fs_zip.h"
3439 #include "wx/zipstrm.h"
3440
3441 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3442
3443 static void TestZipStreamRead()
3444 {
3445     wxPuts(_T("*** Testing ZIP reading ***\n"));
3446
3447     static const wxString filename = _T("foo");
3448     wxFFileInputStream in(TESTFILE_ZIP);
3449     wxZipInputStream istr(in);
3450     wxZipEntry entry(filename);
3451     istr.OpenEntry(entry);
3452
3453     wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
3454
3455     wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
3456     while ( !istr.Eof() )
3457     {
3458         wxPutchar(istr.GetC());
3459         fflush(stdout);
3460     }
3461
3462     wxPuts(_T("\n----- done ------"));
3463 }
3464
3465 static void DumpZipDirectory(wxFileSystem& fs,
3466                              const wxString& dir,
3467                              const wxString& indent)
3468 {
3469     wxString prefix = wxString::Format(_T("%s#zip:%s"),
3470                                          TESTFILE_ZIP, dir.c_str());
3471     wxString wildcard = prefix + _T("/*");
3472
3473     wxString dirname = fs.FindFirst(wildcard, wxDIR);
3474     while ( !dirname.empty() )
3475     {
3476         if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3477         {
3478             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3479
3480             break;
3481         }
3482
3483         wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3484
3485         DumpZipDirectory(fs, dirname,
3486                          indent + wxString(_T(' '), 4));
3487
3488         dirname = fs.FindNext();
3489     }
3490
3491     wxString filename = fs.FindFirst(wildcard, wxFILE);
3492     while ( !filename.empty() )
3493     {
3494         if ( !filename.StartsWith(prefix, &filename) )
3495         {
3496             wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3497
3498             break;
3499         }
3500
3501         wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3502
3503         filename = fs.FindNext();
3504     }
3505 }
3506
3507 static void TestZipFileSystem()
3508 {
3509     wxPuts(_T("*** Testing ZIP file system ***\n"));
3510
3511     wxFileSystem::AddHandler(new wxZipFSHandler);
3512     wxFileSystem fs;
3513     wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3514
3515     DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3516 }
3517
3518 #endif // TEST_ZIP
3519
3520 // ----------------------------------------------------------------------------
3521 // date time
3522 // ----------------------------------------------------------------------------
3523
3524 #ifdef TEST_DATETIME
3525
3526 #include "wx/math.h"
3527 #include "wx/datetime.h"
3528
3529 // this test miscellaneous static wxDateTime functions
3530
3531 #if TEST_ALL
3532
3533 static void TestTimeStatic()
3534 {
3535     wxPuts(_T("\n*** wxDateTime static methods test ***"));
3536
3537     // some info about the current date
3538     int year = wxDateTime::GetCurrentYear();
3539     wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
3540            year,
3541            wxDateTime::IsLeapYear(year) ? "" : "not ",
3542            wxDateTime::GetNumberOfDays(year));
3543
3544     wxDateTime::Month month = wxDateTime::GetCurrentMonth();
3545     wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
3546            wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
3547            wxDateTime::GetMonthName(month).c_str(),
3548            wxDateTime::GetNumberOfDays(month));
3549 }
3550
3551 // test time zones stuff
3552 static void TestTimeZones()
3553 {
3554     wxPuts(_T("\n*** wxDateTime timezone test ***"));
3555
3556     wxDateTime now = wxDateTime::Now();
3557
3558     wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
3559     wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
3560     wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
3561     wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
3562     wxPrintf(_T("               Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
3563     wxPrintf(_T("             New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
3564
3565     wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3566
3567     wxDateTime::Tm tm = now.GetTm();
3568     if ( wxDateTime(tm) != now )
3569     {
3570         wxPrintf(_T("ERROR: got %s instead of %s\n"),
3571                  wxDateTime(tm).Format().c_str(), now.Format().c_str());
3572     }
3573 }
3574
3575 // test some minimal support for the dates outside the standard range
3576 static void TestTimeRange()
3577 {
3578     wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
3579
3580     static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
3581
3582     wxPrintf(_T("Unix epoch:\t%s\n"),
3583              wxDateTime(2440587.5).Format(fmt).c_str());
3584     wxPrintf(_T("Feb 29, 0: \t%s\n"),
3585              wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3586     wxPrintf(_T("JDN 0:     \t%s\n"),
3587              wxDateTime(0.0).Format(fmt).c_str());
3588     wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3589              wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3590     wxPrintf(_T("May 29, 2099:\t%s\n"),
3591              wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
3592 }
3593
3594 // test DST calculations
3595 static void TestTimeDST()
3596 {
3597     wxPuts(_T("\n*** wxDateTime DST test ***"));
3598
3599     wxPrintf(_T("DST is%s in effect now.\n\n"),
3600              wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
3601
3602     for ( int year = 1990; year < 2005; year++ )
3603     {
3604         wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3605                  year,
3606                  wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3607                  wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
3608     }
3609 }
3610
3611 #endif // TEST_ALL
3612
3613 #if TEST_INTERACTIVE
3614
3615 static void TestDateTimeInteractive()
3616 {
3617     wxPuts(_T("\n*** interactive wxDateTime tests ***"));
3618
3619     wxChar buf[128];
3620
3621     for ( ;; )
3622     {
3623         wxPrintf(_T("Enter a date: "));
3624         if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
3625             break;
3626
3627         // kill the last '\n'
3628         buf[wxStrlen(buf) - 1] = 0;
3629
3630         wxDateTime dt;
3631         const wxChar *p = dt.ParseDate(buf);
3632         if ( !p )
3633         {
3634             wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
3635
3636             continue;
3637         }
3638         else if ( *p )
3639         {
3640             wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
3641         }
3642
3643         wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3644                  dt.Format(_T("%b %d, %Y")).c_str(),
3645                  dt.GetDayOfYear(),
3646                  dt.GetWeekOfMonth(wxDateTime::Monday_First),
3647                  dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3648                  dt.GetWeekOfYear(wxDateTime::Monday_First));
3649     }
3650
3651     wxPuts(_T("\n*** done ***"));
3652 }
3653
3654 #endif // TEST_INTERACTIVE
3655
3656 #if TEST_ALL
3657
3658 static void TestTimeMS()
3659 {
3660     wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
3661
3662     wxDateTime dt1 = wxDateTime::Now(),
3663                dt2 = wxDateTime::UNow();
3664
3665     wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
3666     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3667     wxPrintf(_T("Dummy loop: "));
3668     for ( int i = 0; i < 6000; i++ )
3669     {
3670         //for ( int j = 0; j < 10; j++ )
3671         {
3672             wxString s;
3673             s.Printf(_T("%g"), sqrt((float)i));
3674         }
3675
3676         if ( !(i % 100) )
3677             wxPutchar('.');
3678     }
3679     wxPuts(_T(", done"));
3680
3681     dt1 = dt2;
3682     dt2 = wxDateTime::UNow();
3683     wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3684
3685     wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
3686
3687     wxPuts(_T("\n*** done ***"));
3688 }
3689
3690 static void TestTimeHolidays()
3691 {
3692     wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
3693
3694     wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3695     wxDateTime dtStart(1, tm.mon, tm.year),
3696                dtEnd = dtStart.GetLastMonthDay();
3697
3698     wxDateTimeArray hol;
3699     wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3700
3701     const wxChar *format = _T("%d-%b-%Y (%a)");
3702
3703     wxPrintf(_T("All holidays between %s and %s:\n"),
3704            dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3705
3706     size_t count = hol.GetCount();
3707     for ( size_t n = 0; n < count; n++ )
3708     {
3709         wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
3710     }
3711
3712     wxPuts(wxEmptyString);
3713 }
3714
3715 static void TestTimeZoneBug()
3716 {
3717     wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
3718
3719     wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3720     for ( int i = 0; i < 31; i++ )
3721     {
3722         wxPrintf(_T("Date %s: week day %s.\n"),
3723                date.Format(_T("%d-%m-%Y")).c_str(),
3724                date.GetWeekDayName(date.GetWeekDay()).c_str());
3725
3726         date += wxDateSpan::Day();
3727     }
3728
3729     wxPuts(wxEmptyString);
3730 }
3731
3732 static void TestTimeSpanFormat()
3733 {
3734     wxPuts(_T("\n*** wxTimeSpan tests ***"));
3735
3736     static const wxChar *formats[] =
3737     {
3738         _T("(default) %H:%M:%S"),
3739         _T("%E weeks and %D days"),
3740         _T("%l milliseconds"),
3741         _T("(with ms) %H:%M:%S:%l"),
3742         _T("100%% of minutes is %M"),       // test "%%"
3743         _T("%D days and %H hours"),
3744         _T("or also %S seconds"),
3745     };
3746
3747     wxTimeSpan ts1(1, 2, 3, 4),
3748                 ts2(111, 222, 333);
3749     for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3750     {
3751         wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
3752                ts1.Format(formats[n]).c_str(),
3753                ts2.Format(formats[n]).c_str());
3754     }
3755
3756     wxPuts(wxEmptyString);
3757 }
3758
3759 #endif // TEST_ALL
3760
3761 #endif // TEST_DATETIME
3762
3763 // ----------------------------------------------------------------------------
3764 // wxTextInput/OutputStream
3765 // ----------------------------------------------------------------------------
3766
3767 #ifdef TEST_TEXTSTREAM
3768
3769 #include "wx/txtstrm.h"
3770 #include "wx/wfstream.h"
3771
3772 static void TestTextInputStream()
3773 {
3774     wxPuts(_T("\n*** wxTextInputStream test ***"));
3775
3776     wxString filename = _T("testdata.fc");
3777     wxFileInputStream fsIn(filename);
3778     if ( !fsIn.Ok() )
3779     {
3780         wxPuts(_T("ERROR: couldn't open file."));
3781     }
3782     else
3783     {
3784         wxTextInputStream tis(fsIn);
3785
3786         size_t line = 1;
3787         for ( ;; )
3788         {
3789             const wxString s = tis.ReadLine();
3790
3791             // line could be non empty if the last line of the file isn't
3792             // terminated with EOL
3793             if ( fsIn.Eof() && s.empty() )
3794                 break;
3795
3796             wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
3797         }
3798     }
3799 }
3800
3801 #endif // TEST_TEXTSTREAM
3802
3803 // ----------------------------------------------------------------------------
3804 // threads
3805 // ----------------------------------------------------------------------------
3806
3807 #ifdef TEST_THREADS
3808
3809 #include "wx/thread.h"
3810
3811 static size_t gs_counter = (size_t)-1;
3812 static wxCriticalSection gs_critsect;
3813 static wxSemaphore gs_cond;
3814
3815 class MyJoinableThread : public wxThread
3816 {
3817 public:
3818     MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3819         { m_n = n; Create(); }
3820
3821     // thread execution starts here
3822     virtual ExitCode Entry();
3823
3824 private:
3825     size_t m_n;
3826 };
3827
3828 wxThread::ExitCode MyJoinableThread::Entry()
3829 {
3830     unsigned long res = 1;
3831     for ( size_t n = 1; n < m_n; n++ )
3832     {
3833         res *= n;
3834
3835         // it's a loooong calculation :-)
3836         Sleep(100);
3837     }
3838
3839     return (ExitCode)res;
3840 }
3841
3842 class MyDetachedThread : public wxThread
3843 {
3844 public:
3845     MyDetachedThread(size_t n, wxChar ch)
3846     {
3847         m_n = n;
3848         m_ch = ch;
3849         m_cancelled = false;
3850
3851         Create();
3852     }
3853
3854     // thread execution starts here
3855     virtual ExitCode Entry();
3856
3857     // and stops here
3858     virtual void OnExit();
3859
3860 private:
3861     size_t m_n; // number of characters to write
3862     wxChar m_ch;  // character to write
3863
3864     bool m_cancelled;   // false if we exit normally
3865 };
3866
3867 wxThread::ExitCode MyDetachedThread::Entry()
3868 {
3869     {
3870         wxCriticalSectionLocker lock(gs_critsect);
3871         if ( gs_counter == (size_t)-1 )
3872             gs_counter = 1;
3873         else
3874             gs_counter++;
3875     }
3876
3877     for ( size_t n = 0; n < m_n; n++ )
3878     {
3879         if ( TestDestroy() )
3880         {
3881             m_cancelled = true;
3882
3883             break;
3884         }
3885
3886         wxPutchar(m_ch);
3887         fflush(stdout);
3888
3889         wxThread::Sleep(100);
3890     }
3891
3892     return 0;
3893 }
3894
3895 void MyDetachedThread::OnExit()
3896 {
3897     wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
3898
3899     wxCriticalSectionLocker lock(gs_critsect);
3900     if ( !--gs_counter && !m_cancelled )
3901         gs_cond.Post();
3902 }
3903
3904 static void TestDetachedThreads()
3905 {
3906     wxPuts(_T("\n*** Testing detached threads ***"));
3907
3908     static const size_t nThreads = 3;
3909     MyDetachedThread *threads[nThreads];
3910     size_t n;
3911     for ( n = 0; n < nThreads; n++ )
3912     {
3913         threads[n] = new MyDetachedThread(10, 'A' + n);
3914     }
3915
3916     threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
3917     threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
3918
3919     for ( n = 0; n < nThreads; n++ )
3920     {
3921         threads[n]->Run();
3922     }
3923
3924     // wait until all threads terminate
3925     gs_cond.Wait();
3926
3927     wxPuts(wxEmptyString);
3928 }
3929
3930 static void TestJoinableThreads()
3931 {
3932     wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
3933
3934     // calc 10! in the background
3935     MyJoinableThread thread(10);
3936     thread.Run();
3937
3938     wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
3939              (unsigned long)thread.Wait());
3940 }
3941
3942 static void TestThreadSuspend()
3943 {
3944     wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
3945
3946     MyDetachedThread *thread = new MyDetachedThread(15, 'X');
3947
3948     thread->Run();
3949
3950     // this is for this demo only, in a real life program we'd use another
3951     // condition variable which would be signaled from wxThread::Entry() to
3952     // tell us that the thread really started running - but here just wait a
3953     // bit and hope that it will be enough (the problem is, of course, that
3954     // the thread might still not run when we call Pause() which will result
3955     // in an error)
3956     wxThread::Sleep(300);
3957
3958     for ( size_t n = 0; n < 3; n++ )
3959     {
3960         thread->Pause();
3961
3962         wxPuts(_T("\nThread suspended"));
3963         if ( n > 0 )
3964         {
3965             // don't sleep but resume immediately the first time
3966             wxThread::Sleep(300);
3967         }
3968         wxPuts(_T("Going to resume the thread"));
3969
3970         thread->Resume();
3971     }
3972
3973     wxPuts(_T("Waiting until it terminates now"));
3974
3975     // wait until the thread terminates
3976     gs_cond.Wait();
3977
3978     wxPuts(wxEmptyString);
3979 }
3980
3981 static void TestThreadDelete()
3982 {
3983     // As above, using Sleep() is only for testing here - we must use some
3984     // synchronisation object instead to ensure that the thread is still
3985     // running when we delete it - deleting a detached thread which already
3986     // terminated will lead to a crash!
3987
3988     wxPuts(_T("\n*** Testing thread delete function ***"));
3989
3990     MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
3991
3992     thread0->Delete();
3993
3994     wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
3995
3996     MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
3997
3998     thread1->Run();
3999
4000     wxThread::Sleep(300);
4001
4002     thread1->Delete();
4003
4004     wxPuts(_T("\nDeleted a running thread."));
4005
4006     MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
4007
4008     thread2->Run();
4009
4010     wxThread::Sleep(300);
4011
4012     thread2->Pause();
4013
4014     thread2->Delete();
4015
4016     wxPuts(_T("\nDeleted a sleeping thread."));
4017
4018     MyJoinableThread thread3(20);
4019     thread3.Run();
4020
4021     thread3.Delete();
4022
4023     wxPuts(_T("\nDeleted a joinable thread."));
4024
4025     MyJoinableThread thread4(2);
4026     thread4.Run();
4027
4028     wxThread::Sleep(300);
4029
4030     thread4.Delete();
4031
4032     wxPuts(_T("\nDeleted a joinable thread which already terminated."));
4033
4034     wxPuts(wxEmptyString);
4035 }
4036
4037 class MyWaitingThread : public wxThread
4038 {
4039 public:
4040     MyWaitingThread( wxMutex *mutex, wxCondition *condition )
4041     {
4042         m_mutex = mutex;
4043         m_condition = condition;
4044
4045         Create();
4046     }
4047
4048     virtual ExitCode Entry()
4049     {
4050         wxPrintf(_T("Thread %lu has started running.\n"), GetId());
4051         fflush(stdout);
4052
4053         gs_cond.Post();
4054
4055         wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
4056         fflush(stdout);
4057
4058         m_mutex->Lock();
4059         m_condition->Wait();
4060         m_mutex->Unlock();
4061
4062         wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
4063         fflush(stdout);
4064
4065         return 0;
4066     }
4067
4068 private:
4069     wxMutex *m_mutex;
4070     wxCondition *m_condition;
4071 };
4072
4073 static void TestThreadConditions()
4074 {
4075     wxMutex mutex;
4076     wxCondition condition(mutex);
4077
4078     // otherwise its difficult to understand which log messages pertain to
4079     // which condition
4080     //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
4081     //           condition.GetId(), gs_cond.GetId());
4082
4083     // create and launch threads
4084     MyWaitingThread *threads[10];
4085
4086     size_t n;
4087     for ( n = 0; n < WXSIZEOF(threads); n++ )
4088     {
4089         threads[n] = new MyWaitingThread( &mutex, &condition );
4090     }
4091
4092     for ( n = 0; n < WXSIZEOF(threads); n++ )
4093     {
4094         threads[n]->Run();
4095     }
4096
4097     // wait until all threads run
4098     wxPuts(_T("Main thread is waiting for the other threads to start"));
4099     fflush(stdout);
4100
4101     size_t nRunning = 0;
4102     while ( nRunning < WXSIZEOF(threads) )
4103     {
4104         gs_cond.Wait();
4105
4106         nRunning++;
4107
4108         wxPrintf(_T("Main thread: %u already running\n"), nRunning);
4109         fflush(stdout);
4110     }
4111
4112     wxPuts(_T("Main thread: all threads started up."));
4113     fflush(stdout);
4114
4115     wxThread::Sleep(500);
4116
4117 #if 1
4118     // now wake one of them up
4119     wxPrintf(_T("Main thread: about to signal the condition.\n"));
4120     fflush(stdout);
4121     condition.Signal();
4122 #endif
4123
4124     wxThread::Sleep(200);
4125
4126     // wake all the (remaining) threads up, so that they can exit
4127     wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
4128     fflush(stdout);
4129     condition.Broadcast();
4130
4131     // give them time to terminate (dirty!)
4132     wxThread::Sleep(500);
4133 }
4134
4135 #include "wx/utils.h"
4136
4137 class MyExecThread : public wxThread
4138 {
4139 public:
4140     MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
4141                                             m_command(command)
4142     {
4143         Create();
4144     }
4145
4146     virtual ExitCode Entry()
4147     {
4148         return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
4149     }
4150
4151 private:
4152     wxString m_command;
4153 };
4154
4155 static void TestThreadExec()
4156 {
4157     wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
4158
4159     MyExecThread thread(_T("true"));
4160     thread.Run();
4161
4162     wxPrintf(_T("Main program exit code: %ld.\n"),
4163              wxExecute(_T("false"), wxEXEC_SYNC));
4164
4165     wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
4166 }
4167
4168 // semaphore tests
4169 #include "wx/datetime.h"
4170
4171 class MySemaphoreThread : public wxThread
4172 {
4173 public:
4174     MySemaphoreThread(int i, wxSemaphore *sem)
4175         : wxThread(wxTHREAD_JOINABLE),
4176           m_sem(sem),
4177           m_i(i)
4178     {
4179         Create();
4180     }
4181
4182     virtual ExitCode Entry()
4183     {
4184         wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
4185                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4186
4187         m_sem->Wait();
4188
4189         wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
4190                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4191
4192         Sleep(1000);
4193
4194         wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
4195                  wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4196
4197         m_sem->Post();
4198
4199         return 0;
4200     }
4201
4202 private:
4203     wxSemaphore *m_sem;
4204     int m_i;
4205 };
4206
4207 WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
4208
4209 static void TestSemaphore()
4210 {
4211     wxPuts(_T("*** Testing wxSemaphore class. ***"));
4212
4213     static const int SEM_LIMIT = 3;
4214
4215     wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
4216     ArrayThreads threads;
4217
4218     for ( int i = 0; i < 3*SEM_LIMIT; i++ )
4219     {
4220         threads.Add(new MySemaphoreThread(i, &sem));
4221         threads.Last()->Run();
4222     }
4223
4224     for ( size_t n = 0; n < threads.GetCount(); n++ )
4225     {
4226         threads[n]->Wait();
4227         delete threads[n];
4228     }
4229 }
4230
4231 #endif // TEST_THREADS
4232
4233 // ----------------------------------------------------------------------------
4234 // entry point
4235 // ----------------------------------------------------------------------------
4236
4237 #ifdef TEST_SNGLINST
4238     #include "wx/snglinst.h"
4239 #endif // TEST_SNGLINST
4240
4241 int main(int argc, char **argv)
4242 {
4243 #if wxUSE_UNICODE
4244     wxChar **wxArgv = new wxChar *[argc + 1];
4245
4246     {
4247         int n;
4248
4249         for (n = 0; n < argc; n++ )
4250         {
4251             wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
4252             wxArgv[n] = wxStrdup(warg);
4253         }
4254
4255         wxArgv[n] = NULL;
4256     }
4257 #else // !wxUSE_UNICODE
4258     #define wxArgv argv
4259 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
4260
4261     wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
4262
4263     wxInitializer initializer;
4264     if ( !initializer )
4265     {
4266         fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
4267
4268         return -1;
4269     }
4270
4271 #ifdef TEST_SNGLINST
4272     wxSingleInstanceChecker checker;
4273     if ( checker.Create(_T(".wxconsole.lock")) )
4274     {
4275         if ( checker.IsAnotherRunning() )
4276         {
4277             wxPrintf(_T("Another instance of the program is running, exiting.\n"));
4278
4279             return 1;
4280         }
4281
4282         // wait some time to give time to launch another instance
4283         wxPrintf(_T("Press \"Enter\" to continue..."));
4284         wxFgetc(stdin);
4285     }
4286     else // failed to create
4287     {
4288         wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
4289     }
4290 #endif // TEST_SNGLINST
4291
4292 #ifdef TEST_CMDLINE
4293     TestCmdLineConvert();
4294
4295 #if wxUSE_CMDLINE_PARSER
4296     static const wxCmdLineEntryDesc cmdLineDesc[] =
4297     {
4298         { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
4299             wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
4300         { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
4301         { wxCMD_LINE_SWITCH, "q", "quiet",   "be quiet" },
4302
4303         { wxCMD_LINE_OPTION, "o", "output",  "output file" },
4304         { wxCMD_LINE_OPTION, "i", "input",   "input dir" },
4305         { wxCMD_LINE_OPTION, "s", "size",    "output block size",
4306             wxCMD_LINE_VAL_NUMBER },
4307         { wxCMD_LINE_OPTION, "d", "date",    "output file date",
4308             wxCMD_LINE_VAL_DATE },
4309         { wxCMD_LINE_OPTION, "f", "double",  "output double",
4310             wxCMD_LINE_VAL_DOUBLE },
4311
4312         { wxCMD_LINE_PARAM,  NULL, NULL, "input file",
4313             wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
4314
4315         { wxCMD_LINE_NONE }
4316     };
4317
4318     wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
4319
4320     parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
4321                      wxCMD_LINE_VAL_STRING,
4322                      wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
4323
4324     switch ( parser.Parse() )
4325     {
4326         case -1:
4327             wxLogMessage(_T("Help was given, terminating."));
4328             break;
4329
4330         case 0:
4331             ShowCmdLine(parser);
4332             break;
4333
4334         default:
4335             wxLogMessage(_T("Syntax error detected, aborting."));
4336             break;
4337     }
4338 #endif // wxUSE_CMDLINE_PARSER
4339
4340 #endif // TEST_CMDLINE
4341
4342 #ifdef TEST_DIR
4343     #if TEST_ALL
4344         TestDirExists();
4345         TestDirEnum();
4346     #endif
4347     TestDirTraverse();
4348 #endif // TEST_DIR
4349
4350 #ifdef TEST_DYNLIB
4351     TestDllLoad();
4352     TestDllListLoaded();
4353 #endif // TEST_DYNLIB
4354
4355 #ifdef TEST_ENVIRON
4356     TestEnvironment();
4357 #endif // TEST_ENVIRON
4358
4359 #ifdef TEST_EXECUTE
4360     TestExecute();
4361 #endif // TEST_EXECUTE
4362
4363 #ifdef TEST_FILECONF
4364     TestFileConfRead();
4365 #endif // TEST_FILECONF
4366
4367 #ifdef TEST_LOCALE
4368     TestDefaultLang();
4369 #endif // TEST_LOCALE
4370
4371 #ifdef TEST_LOG
4372     wxPuts(_T("*** Testing wxLog ***"));
4373
4374     wxString s;
4375     for ( size_t n = 0; n < 8000; n++ )
4376     {
4377         s << (wxChar)(_T('A') + (n % 26));
4378     }
4379
4380     wxLogWarning(_T("The length of the string is %lu"),
4381                  (unsigned long)s.length());
4382
4383     wxString msg;
4384     msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
4385
4386     // this one shouldn't be truncated
4387     wxPrintf(msg);
4388
4389     // but this one will because log functions use fixed size buffer
4390     // (note that it doesn't need '\n' at the end neither - will be added
4391     //  by wxLog anyhow)
4392     wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
4393 #endif // TEST_LOG
4394
4395 #ifdef TEST_FILE
4396     TestFileRead();
4397     TestTextFileRead();
4398     TestFileCopy();
4399     TestTempFile();
4400 #endif // TEST_FILE
4401
4402 #ifdef TEST_FILENAME
4403     TestFileNameTemp();
4404     TestFileNameCwd();
4405     TestFileNameDirManip();
4406     TestFileNameComparison();
4407     TestFileNameOperations();
4408 #endif // TEST_FILENAME
4409
4410 #ifdef TEST_FILETIME
4411     TestFileGetTimes();
4412     #if 0
4413     TestFileSetTimes();
4414     #endif
4415 #endif // TEST_FILETIME
4416
4417 #ifdef TEST_FTP
4418     wxLog::AddTraceMask(FTP_TRACE_MASK);
4419     if ( TestFtpConnect() )
4420     {
4421         #if TEST_ALL
4422             TestFtpList();
4423             TestFtpDownload();
4424             TestFtpMisc();
4425             TestFtpFileSize();
4426             TestFtpUpload();
4427         #endif // TEST_ALL
4428
4429         #if TEST_INTERACTIVE
4430             TestFtpInteractive();
4431         #endif
4432     }
4433     //else: connecting to the FTP server failed
4434
4435     #if 0
4436         TestFtpWuFtpd();
4437     #endif
4438 #endif // TEST_FTP
4439
4440 #ifdef TEST_MIME
4441     //wxLog::AddTraceMask(_T("mime"));
4442     TestMimeEnum();
4443 #if 0
4444     TestMimeOverride();
4445     TestMimeAssociate();
4446 #endif
4447     TestMimeFilename();
4448 #endif // TEST_MIME
4449
4450 #ifdef TEST_INFO_FUNCTIONS
4451     TestOsInfo();
4452     TestPlatformInfo();
4453     TestUserInfo();
4454
4455     #if TEST_INTERACTIVE
4456         TestDiskInfo();
4457     #endif
4458 #endif // TEST_INFO_FUNCTIONS
4459
4460 #ifdef TEST_PATHLIST
4461     TestPathList();
4462 #endif // TEST_PATHLIST
4463
4464 #ifdef TEST_PRINTF
4465     TestPrintf();
4466 #endif // TEST_PRINTF
4467
4468 #ifdef TEST_REGCONF
4469     #if 0
4470     TestRegConfWrite();
4471     #endif
4472     TestRegConfRead();
4473 #endif // TEST_REGCONF
4474
4475 #if defined TEST_REGEX && TEST_INTERACTIVE
4476     TestRegExInteractive();
4477 #endif // defined TEST_REGEX && TEST_INTERACTIVE
4478
4479 #ifdef TEST_REGISTRY
4480     TestRegistryRead();
4481     TestRegistryAssociation();
4482 #endif // TEST_REGISTRY
4483
4484 #ifdef TEST_SOCKETS
4485     TestSocketServer();
4486     TestSocketClient();
4487 #endif // TEST_SOCKETS
4488
4489 #ifdef TEST_STREAMS
4490     #if TEST_ALL
4491         TestFileStream();
4492     #endif
4493         TestMemoryStream();
4494 #endif // TEST_STREAMS
4495
4496 #ifdef TEST_TEXTSTREAM
4497     TestTextInputStream();
4498 #endif // TEST_TEXTSTREAM
4499
4500 #ifdef TEST_THREADS
4501     int nCPUs = wxThread::GetCPUCount();
4502     wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
4503     if ( nCPUs != -1 )
4504         wxThread::SetConcurrency(nCPUs);
4505
4506         TestJoinableThreads();
4507
4508     #if TEST_ALL
4509         TestJoinableThreads();
4510         TestDetachedThreads();
4511         TestThreadSuspend();
4512         TestThreadDelete();
4513         TestThreadConditions();
4514         TestThreadExec();
4515         TestSemaphore();
4516     #endif
4517 #endif // TEST_THREADS
4518
4519 #ifdef TEST_TIMER
4520     TestStopWatch();
4521     TestTimer();
4522 #endif // TEST_TIMER
4523
4524 #ifdef TEST_DATETIME
4525     #if TEST_ALL
4526         TestTimeStatic();
4527         TestTimeRange();
4528         TestTimeZones();
4529         TestTimeDST();
4530         TestTimeHolidays();
4531         TestTimeSpanFormat();
4532         TestTimeMS();
4533
4534         TestTimeZoneBug();
4535     #endif
4536
4537     #if TEST_INTERACTIVE
4538         TestDateTimeInteractive();
4539     #endif
4540 #endif // TEST_DATETIME
4541
4542 #ifdef TEST_SCOPEGUARD
4543     TestScopeGuard();
4544 #endif
4545
4546 #ifdef TEST_STACKWALKER
4547 #if wxUSE_STACKWALKER
4548     TestStackWalk(argv[0]);
4549 #endif
4550 #endif // TEST_STACKWALKER
4551
4552 #ifdef TEST_STDPATHS
4553     TestStandardPaths();
4554 #endif
4555
4556 #ifdef TEST_USLEEP
4557     wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
4558     wxUsleep(3000);
4559 #endif // TEST_USLEEP
4560
4561 #ifdef TEST_VCARD
4562     TestVCardRead();
4563     TestVCardWrite();
4564 #endif // TEST_VCARD
4565
4566 #ifdef TEST_VOLUME
4567     TestFSVolume();
4568 #endif // TEST_VOLUME
4569
4570 #ifdef TEST_WCHAR
4571     TestUtf8();
4572     TestEncodingConverter();
4573 #endif // TEST_WCHAR
4574
4575 #ifdef TEST_ZIP
4576     TestZipStreamRead();
4577     TestZipFileSystem();
4578 #endif // TEST_ZIP
4579
4580 #if wxUSE_UNICODE
4581     {
4582         for ( int n = 0; n < argc; n++ )
4583             free(wxArgv[n]);
4584
4585         delete [] wxArgv;
4586     }
4587 #endif // wxUSE_UNICODE
4588
4589     wxUnusedVar(argc);
4590     wxUnusedVar(argv);
4591     return 0;
4592 }