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