]> git.saurik.com Git - wxWidgets.git/blame - samples/console/console.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
don't use wxVector<wxDataFormat> from wx/clipbrd.h as wxDataFormat definition is...
[wxWidgets.git] / samples / console / console.cpp
CommitLineData
37667812
VZ		 1/////////////////////////////////////////////////////////////////////////////
2// Name: samples/console/console.cpp
f6c9f2ed 3// Purpose: A sample console (as opposed to GUI) program using wxWidgets
37667812
VZ		 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
42fb9cdf
FM		 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
e87271f3
VZ		 63// ============================================================================
64// declarations
65// ============================================================================
66
67// ----------------------------------------------------------------------------
68// headers
69// ----------------------------------------------------------------------------
70
e84010cf 71#include "wx/defs.h"
b11a23f3 72
37667812
VZ		 73#include <stdio.h>
74
e84010cf
GD		 75#include "wx/string.h"
76#include "wx/file.h"
06fe46e2 77#include "wx/filename.h"
e84010cf 78#include "wx/app.h"
e046e5f1 79#include "wx/log.h"
8bb6b2c0
VZ		 80#include "wx/apptrait.h"
81#include "wx/platinfo.h"
74e10fcc 82#include "wx/wxchar.h"
e87271f3 83
d31b7b68
VZ		 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
e87271f3
VZ		 90// ----------------------------------------------------------------------------
91// conditional compilation
92// ----------------------------------------------------------------------------
93
daa2c7d9
VZ		 94/*
95 A note about all these conditional compilation macros: this file is used
be5a51fb 96 both as a test suite for various non-GUI wxWidgets classes and as a
daa2c7d9
VZ		 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
e9d2bb6f
DS		 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.
fc3762b5 104#define TEST_ALL 0
e9d2bb6f
DS		 105
106
107#if TEST_ALL
31f6de22
VZ		 108 #define TEST_CMDLINE
109 #define TEST_DATETIME
110 #define TEST_DIR
93ed8ff7 111 #define TEST_DYNLIB
31f6de22
VZ		 112 #define TEST_ENVIRON
113 #define TEST_EXECUTE
114 #define TEST_FILE
115 #define TEST_FILECONF
116 #define TEST_FILENAME
117 #define TEST_FILETIME
8d4dc98f 118 // #define TEST_FTP --FIXME! (RN)
31f6de22 119 #define TEST_INFO_FUNCTIONS
31f6de22
VZ		 120 #define TEST_LOCALE
121 #define TEST_LOG
31f6de22 122 #define TEST_MIME
af266e5b 123 #define TEST_MODULE
31f6de22 124 #define TEST_PATHLIST
7aeebdcd 125 #define TEST_PRINTF
31f6de22
VZ		 126 #define TEST_REGCONF
127 #define TEST_REGEX
128 #define TEST_REGISTRY
24c8053b 129 #define TEST_SCOPEGUARD
31f6de22 130 #define TEST_SNGLINST
8d4dc98f 131// #define TEST_SOCKETS --FIXME! (RN)
eaff0f0d 132 #define TEST_STACKWALKER
af33b199 133 #define TEST_STDPATHS
31f6de22 134 #define TEST_STREAMS
39937656 135 #define TEST_TEXTSTREAM
31f6de22
VZ		 136 #define TEST_THREADS
137 #define TEST_TIMER
138 // #define TEST_VCARD -- don't enable this (VZ)
8d4dc98f 139// #define TEST_VOLUME --FIXME! (RN)
31f6de22
VZ		 140 #define TEST_WCHAR
141 #define TEST_ZIP
e9d2bb6f 142#else // #if TEST_ALL
fc3762b5 143 #define TEST_FTP
31f6de22 144#endif
f6bcfd97 145
daa2c7d9
VZ		 146// some tests are interactive, define this to run them
147#ifdef TEST_INTERACTIVE
148 #undef TEST_INTERACTIVE
149
e9d2bb6f 150 #define TEST_INTERACTIVE 1
daa2c7d9 151#else
e9d2bb6f 152 #define TEST_INTERACTIVE 0
daa2c7d9 153#endif
58b24a56 154
e87271f3
VZ		 155// ============================================================================
156// implementation
157// ============================================================================
158
8e907a13
VZ		 159// ----------------------------------------------------------------------------
160// helper functions
161// ----------------------------------------------------------------------------
162
1cd53e88 163#if defined(TEST_SOCKETS)
8e907a13
VZ		 164
165// replace TABs with \t and CRs with \n
166static 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
d34bce84
VZ		 178// ----------------------------------------------------------------------------
179// wxCmdLineParser
180// ----------------------------------------------------------------------------
181
d31b7b68
VZ		 182#ifdef TEST_CMDLINE
183
e84010cf
GD		 184#include "wx/cmdline.h"
185#include "wx/datetime.h"
d34bce84 186
31f6de22
VZ		 187#if wxUSE_CMDLINE_PARSER
188
d34bce84
VZ		 189static void ShowCmdLine(const wxCmdLineParser& parser)
190{
5df663af 191 wxString s = _T("Command line parsed successfully:\nInput files: ");
d34bce84
VZ		 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'
456ae26d
VZ		 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';
d34bce84
VZ		 202
203 wxString strVal;
204 long lVal;
b1859b1a 205 double dVal;
d34bce84 206 wxDateTime dt;
456ae26d
VZ		 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';
b1859b1a
VZ		 213 if ( parser.Found(_T("f"), &dVal) )
214 s << _T("Double:\t") << dVal << '\n';
456ae26d
VZ		 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';
d34bce84
VZ		 219
220 wxLogMessage(s);
221}
222
31f6de22
VZ		 223#endif // wxUSE_CMDLINE_PARSER
224
225static void TestCmdLineConvert()
226{
456ae26d 227 static const wxChar *cmdlines[] =
31f6de22 228 {
456ae26d
VZ		 229 _T("arg1 arg2"),
230 _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
231 _T("literal \\\" and \"\""),
31f6de22
VZ		 232 };
233
234 for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
235 {
456ae26d
VZ		 236 const wxChar *cmdline = cmdlines[n];
237 wxPrintf(_T("Parsing: %s\n"), cmdline);
31f6de22
VZ		 238 wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
239
240 size_t count = args.GetCount();
456ae26d 241 wxPrintf(_T("\targc = %u\n"), count);
31f6de22
VZ		 242 for ( size_t arg = 0; arg < count; arg++ )
243 {
456ae26d 244 wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
31f6de22
VZ		 245 }
246 }
247}
248
d34bce84
VZ		 249#endif // TEST_CMDLINE
250
1944c6bd
VZ		 251// ----------------------------------------------------------------------------
252// wxDir
253// ----------------------------------------------------------------------------
254
255#ifdef TEST_DIR
256
e84010cf 257#include "wx/dir.h"
1944c6bd 258
35332784
VZ		 259#ifdef __UNIX__
260 static const wxChar *ROOTDIR = _T("/");
2f0c19d0 261 static const wxChar *TESTDIR = _T("/usr/local/share");
65e324b4 262#elif defined(__WXMSW__) || defined(__DOS__) || defined(__OS2__)
35332784
VZ		 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
1944c6bd
VZ		 269static 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 {
456ae26d 281 wxPrintf(_T("\t%s\n"), filename.c_str());
1944c6bd
VZ		 282
283 cont = dir.GetNext(&filename);
284 }
285
e9d2bb6f 286 wxPuts(wxEmptyString);
1944c6bd
VZ		 287}
288
dab6fbae
WS		 289#if TEST_ALL
290
1944c6bd
VZ		 291static void TestDirEnum()
292{
456ae26d 293 wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
35332784 294
149147e1 295 wxString cwd = wxGetCwd();
9475670f 296 if ( !wxDir::Exists(cwd) )
149147e1 297 {
456ae26d 298 wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
149147e1
VZ		 299 return;
300 }
301
ee3ef281 302 wxDir dir(cwd);
149147e1
VZ		 303 if ( !dir.IsOpened() )
304 {
456ae26d 305 wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
149147e1
VZ		 306 return;
307 }
1944c6bd 308
456ae26d 309 wxPuts(_T("Enumerating everything in current directory:"));
1944c6bd
VZ		 310 TestDirEnumHelper(dir);
311
456ae26d 312 wxPuts(_T("Enumerating really everything in current directory:"));
1944c6bd
VZ		 313 TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
314
456ae26d 315 wxPuts(_T("Enumerating object files in current directory:"));
f2cb8a17 316 TestDirEnumHelper(dir, wxDIR_DEFAULT, _T("*.o*"));
1944c6bd 317
456ae26d 318 wxPuts(_T("Enumerating directories in current directory:"));
1944c6bd
VZ		 319 TestDirEnumHelper(dir, wxDIR_DIRS);
320
456ae26d 321 wxPuts(_T("Enumerating files in current directory:"));
1944c6bd
VZ		 322 TestDirEnumHelper(dir, wxDIR_FILES);
323
456ae26d 324 wxPuts(_T("Enumerating files including hidden in current directory:"));
1944c6bd
VZ		 325 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
326
35332784 327 dir.Open(ROOTDIR);
1944c6bd 328
456ae26d 329 wxPuts(_T("Enumerating everything in root directory:"));
1944c6bd
VZ		 330 TestDirEnumHelper(dir, wxDIR_DEFAULT);
331
456ae26d 332 wxPuts(_T("Enumerating directories in root directory:"));
1944c6bd
VZ		 333 TestDirEnumHelper(dir, wxDIR_DIRS);
334
456ae26d 335 wxPuts(_T("Enumerating files in root directory:"));
1944c6bd
VZ		 336 TestDirEnumHelper(dir, wxDIR_FILES);
337
456ae26d 338 wxPuts(_T("Enumerating files including hidden in root directory:"));
1944c6bd
VZ		 339 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
340
456ae26d 341 wxPuts(_T("Enumerating files in non existing directory:"));
f2cb8a17 342 wxDir dirNo(_T("nosuchdir"));
1944c6bd
VZ		 343 TestDirEnumHelper(dirNo);
344}
345
dab6fbae
WS		 346#endif // TEST_ALL
347
35332784
VZ		 348class DirPrintTraverser : public wxDirTraverser
349{
350public:
e9d2bb6f 351 virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
35332784
VZ		 352 {
353 return wxDIR_CONTINUE;
354 }
355
356 virtual wxDirTraverseResult OnDir(const wxString& dirname)
357 {
358 wxString path, name, ext;
bd365871 359 wxFileName::SplitPath(dirname, &path, &name, &ext);
35332784
VZ		 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
456ae26d 371 wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
35332784
VZ		 372
373 return wxDIR_CONTINUE;
374 }
375};
376
377static void TestDirTraverse()
378{
456ae26d 379 wxPuts(_T("*** Testing wxDir::Traverse() ***"));
35332784
VZ		 380
381 // enum all files
382 wxArrayString files;
383 size_t n = wxDir::GetAllFiles(TESTDIR, &files);
456ae26d 384 wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
35332784
VZ		 385 if ( n > 1 )
386 {
456ae26d
VZ		 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());
35332784
VZ		 389 }
390
391 // enum again with custom traverser
2f0c19d0 392 wxPuts(_T("Now enumerating directories:"));
35332784
VZ		 393 wxDir dir(TESTDIR);
394 DirPrintTraverser traverser;
e9d2bb6f 395 dir.Traverse(traverser, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN);
35332784
VZ		 396}
397
dab6fbae
WS		 398#if TEST_ALL
399
149147e1
VZ		 400static void TestDirExists()
401{
402 wxPuts(_T("*** Testing wxDir::Exists() ***"));
403
456ae26d 404 static const wxChar *dirnames[] =
149147e1
VZ		 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 {
456ae26d
VZ		 426 wxPrintf(_T("%-40s: %s\n"),
427 dirnames[n],
428 wxDir::Exists(dirnames[n]) ? _T("exists")
429 : _T("doesn't exist"));
149147e1
VZ		 430 }
431}
432
dab6fbae
WS		 433#endif // TEST_ALL
434
1944c6bd
VZ		 435#endif // TEST_DIR
436
f6bcfd97
BP		 437// ----------------------------------------------------------------------------
438// wxDllLoader
439// ----------------------------------------------------------------------------
440
93ed8ff7 441#ifdef TEST_DYNLIB
f6bcfd97 442
e84010cf 443#include "wx/dynlib.h"
f6bcfd97
BP		 444
445static 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!
e259f83e 452 static const wxChar *LIB_NAME = _T("/lib/libc.so.6");
f6bcfd97
BP		 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
297ebe6b 458 wxPuts(_T("*** testing basic wxDynamicLibrary functions ***\n"));
f6bcfd97 459
456ae26d
VZ		 460 wxDynamicLibrary lib(LIB_NAME);
461 if ( !lib.IsLoaded() )
f6bcfd97
BP		 462 {
463 wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
464 }
465 else
466 {
93ed8ff7 467 typedef int (wxSTDCALL *wxStrlenType)(const char *);
456ae26d 468 wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
f6bcfd97
BP		 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 {
e259f83e
VZ		 476 wxPrintf(_T("Calling %s dynamically loaded from %s "),
477 FUNC_NAME, LIB_NAME);
478
f6bcfd97
BP		 479 if ( pfnStrlen("foo") != 3 )
480 {
456ae26d 481 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
f6bcfd97
BP		 482 }
483 else
484 {
456ae26d 485 wxPuts(_T("... ok"));
f6bcfd97
BP		 486 }
487 }
93ed8ff7
VZ		 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__
f6bcfd97
BP		 508 }
509}
510
297ebe6b
VZ		 511#if defined(__WXMSW__) || defined(__UNIX__)
512
513static 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];
bf3bf677 523 printf("%-45s", (const char *)details.GetPath().mb_str());
297ebe6b
VZ		 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
bf3bf677 533 printf(" %s\n", (const char *)details.GetVersion().mb_str());
297ebe6b
VZ		 534 }
535}
536
537#endif
538
93ed8ff7 539#endif // TEST_DYNLIB
f6bcfd97 540
8fd0d89b
VZ		 541// ----------------------------------------------------------------------------
542// wxGet/SetEnv
543// ----------------------------------------------------------------------------
544
545#ifdef TEST_ENVIRON
546
e84010cf 547#include "wx/utils.h"
8fd0d89b 548
308978f6
VZ		 549static 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
8fd0d89b
VZ		 560static void TestEnvironment()
561{
562 const wxChar *var = _T("wxTestVar");
563
456ae26d 564 wxPuts(_T("*** testing environment access functions ***"));
8fd0d89b 565
456ae26d 566 wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
8fd0d89b 567 wxSetEnv(var, _T("value for wxTestVar"));
456ae26d 568 wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
8fd0d89b 569 wxSetEnv(var, _T("another value"));
456ae26d 570 wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
8fd0d89b 571 wxUnsetEnv(var);
456ae26d
VZ		 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());
8fd0d89b
VZ		 574}
575
576#endif // TEST_ENVIRON
577
d93c719a
VZ		 578// ----------------------------------------------------------------------------
579// wxExecute
580// ----------------------------------------------------------------------------
581
582#ifdef TEST_EXECUTE
583
e84010cf 584#include "wx/utils.h"
d93c719a
VZ		 585
586static void TestExecute()
587{
456ae26d 588 wxPuts(_T("*** testing wxExecute ***"));
d93c719a
VZ		 589
590#ifdef __UNIX__
331abcf7
VZ		 591 #define COMMAND "echo hi"
592 #define ASYNC_COMMAND "xclock"
2c8e4738 593 #define SHELL_COMMAND "echo hi from shell"
ea58aac5 594 #define REDIRECT_COMMAND "cat -n Makefile"
d93c719a 595#elif defined(__WXMSW__)
50ded68d 596 #define COMMAND "command.com /c echo hi"
331abcf7 597 #define ASYNC_COMMAND "notepad"
2c8e4738
VZ		 598 #define SHELL_COMMAND "echo hi"
599 #define REDIRECT_COMMAND COMMAND
d93c719a
VZ		 600#else
601 #error "no command to exec"
602#endif // OS
603
456ae26d 604 wxPrintf(_T("Testing wxShell: "));
2c8e4738 605 fflush(stdout);
f2cb8a17 606 if ( wxShell(_T(SHELL_COMMAND)) )
456ae26d 607 wxPuts(_T("Ok."));
d93c719a 608 else
456ae26d 609 wxPuts(_T("ERROR."));
2c8e4738 610
456ae26d 611 wxPrintf(_T("Testing wxExecute: "));
2c8e4738 612 fflush(stdout);
331abcf7 613 if ( wxExecute(_T(COMMAND), wxEXEC_SYNC) == 0 )
456ae26d 614 wxPuts(_T("Ok."));
2c8e4738 615 else
456ae26d 616 wxPuts(_T("ERROR."));
2c8e4738 617
456ae26d 618 wxPrintf(_T("Testing async wxExecute: "));
2c8e4738 619 fflush(stdout);
42c46d52
VZ		 620 int pid = wxExecute(ASYNC_COMMAND);
621 if ( pid != 0 )
622 {
456ae26d 623 wxPuts(_T("Ok (command launched)."));
42c46d52
VZ		 624 if ( wxKill(pid) == -1 )
625 wxPuts("ERROR: failed to kill child process.");
626 }
2c8e4738 627 else
456ae26d 628 wxPuts(_T("ERROR."));
2c8e4738 629
456ae26d 630 wxPrintf(_T("Testing wxExecute with redirection:\n"));
2c8e4738 631 wxArrayString output;
f2cb8a17 632 if ( wxExecute(_T(REDIRECT_COMMAND), output) != 0 )
2c8e4738 633 {
456ae26d 634 wxPuts(_T("ERROR."));
2c8e4738
VZ		 635 }
636 else
637 {
1282ddbb
VZ		 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++ )
2c8e4738 645 {
ea58aac5 646 wxPrintf("%04u:\t%s\n", n + 1, output[n]);
2c8e4738
VZ		 647 }
648
1282ddbb
VZ		 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
456ae26d 659 wxPuts(_T("Ok."));
2c8e4738 660 }
d93c719a
VZ		 661}
662
663#endif // TEST_EXECUTE
664
f6bcfd97
BP		 665// ----------------------------------------------------------------------------
666// file
667// ----------------------------------------------------------------------------
668
669#ifdef TEST_FILE
670
e84010cf
GD		 671#include "wx/file.h"
672#include "wx/ffile.h"
673#include "wx/textfile.h"
f6bcfd97
BP		 674
675static void TestFileRead()
676{
456ae26d 677 wxPuts(_T("*** wxFile read test ***"));
f6bcfd97
BP		 678
679 wxFile file(_T("testdata.fc"));
680 if ( file.IsOpened() )
681 {
456ae26d 682 wxPrintf(_T("File length: %lu\n"), file.Length());
f6bcfd97 683
456ae26d 684 wxPuts(_T("File dump:\n----------"));
f6bcfd97 685
30984dea 686 static const size_t len = 1024;
456ae26d 687 wxChar buf[len];
f6bcfd97
BP		 688 for ( ;; )
689 {
30984dea
VZ		 690 size_t nRead = file.Read(buf, len);
691 if ( nRead == (size_t)wxInvalidOffset )
f6bcfd97 692 {
456ae26d 693 wxPrintf(_T("Failed to read the file."));
f6bcfd97
BP		 694 break;
695 }
696
697 fwrite(buf, nRead, 1, stdout);
698
699 if ( nRead < len )
700 break;
701 }
702
456ae26d 703 wxPuts(_T("----------"));
f6bcfd97
BP		 704 }
705 else
706 {
456ae26d 707 wxPrintf(_T("ERROR: can't open test file.\n"));
f6bcfd97
BP		 708 }
709
e9d2bb6f 710 wxPuts(wxEmptyString);
f6bcfd97
BP		 711}
712
713static void TestTextFileRead()
714{
456ae26d 715 wxPuts(_T("*** wxTextFile read test ***"));
f6bcfd97
BP		 716
717 wxTextFile file(_T("testdata.fc"));
718 if ( file.Open() )
719 {
456ae26d
VZ		 720 wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
721 wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
3ca6a5f0
BP		 722
723 wxString s;
724
456ae26d 725 wxPuts(_T("\nDumping the entire file:"));
3ca6a5f0
BP		 726 for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
727 {
456ae26d 728 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
3ca6a5f0 729 }
456ae26d 730 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
3ca6a5f0 731
456ae26d 732 wxPuts(_T("\nAnd now backwards:"));
3ca6a5f0
BP		 733 for ( s = file.GetLastLine();
734 file.GetCurrentLine() != 0;
735 s = file.GetPrevLine() )
736 {
456ae26d 737 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
3ca6a5f0 738 }
456ae26d 739 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
f6bcfd97
BP		 740 }
741 else
742 {
456ae26d 743 wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
f6bcfd97
BP		 744 }
745
e9d2bb6f 746 wxPuts(wxEmptyString);
f6bcfd97
BP		 747}
748
a339970a
VZ		 749static void TestFileCopy()
750{
456ae26d 751 wxPuts(_T("*** Testing wxCopyFile ***"));
a339970a
VZ		 752
753 static const wxChar *filename1 = _T("testdata.fc");
754 static const wxChar *filename2 = _T("test2");
755 if ( !wxCopyFile(filename1, filename2) )
756 {
456ae26d 757 wxPuts(_T("ERROR: failed to copy file"));
a339970a
VZ		 758 }
759 else
760 {
f2cb8a17
JS		 761 wxFFile f1(filename1, _T("rb")),
762 f2(filename2, _T("rb"));
a339970a
VZ		 763
764 if ( !f1.IsOpened() || !f2.IsOpened() )
765 {
456ae26d 766 wxPuts(_T("ERROR: failed to open file(s)"));
a339970a
VZ		 767 }
768 else
769 {
770 wxString s1, s2;
771 if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
772 {
456ae26d 773 wxPuts(_T("ERROR: failed to read file(s)"));
a339970a
VZ		 774 }
775 else
776 {
777 if ( (s1.length() != s2.length()) ||
778 (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
779 {
456ae26d 780 wxPuts(_T("ERROR: copy error!"));
a339970a
VZ		 781 }
782 else
783 {
456ae26d 784 wxPuts(_T("File was copied ok."));
a339970a
VZ		 785 }
786 }
787 }
788 }
789
790 if ( !wxRemoveFile(filename2) )
791 {
456ae26d 792 wxPuts(_T("ERROR: failed to remove the file"));
a339970a
VZ		 793 }
794
e9d2bb6f 795 wxPuts(wxEmptyString);
a339970a
VZ		 796}
797
59062ec1
VZ		 798static 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
f6bcfd97
BP		 816#endif // TEST_FILE
817
ee6e1b1d
VZ		 818// ----------------------------------------------------------------------------
819// wxFileConfig
820// ----------------------------------------------------------------------------
821
822#ifdef TEST_FILECONF
823
e84010cf
GD		 824#include "wx/confbase.h"
825#include "wx/fileconf.h"
ee6e1b1d
VZ		 826
827static 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
838static void TestFileConfRead()
839{
456ae26d 840 wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
ee6e1b1d
VZ		 841
842 wxFileConfig fileconf(_T("test"), wxEmptyString,
843 _T("testdata.fc"), wxEmptyString,
844 wxCONFIG_USE_RELATIVE_PATH);
845
846 // test simple reading
456ae26d 847 wxPuts(_T("\nReading config file:"));
ee6e1b1d
VZ		 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);
456ae26d 853 wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
ee6e1b1d
VZ		 854 if ( value == data.value )
855 {
456ae26d 856 wxPuts(_T("(ok)"));
ee6e1b1d
VZ		 857 }
858 else
859 {
456ae26d 860 wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
ee6e1b1d
VZ		 861 }
862 }
863
864 // test enumerating the entries
456ae26d 865 wxPuts(_T("\nEnumerating all root entries:"));
ee6e1b1d
VZ		 866 long dummy;
867 wxString name;
868 bool cont = fileconf.GetFirstEntry(name, dummy);
869 while ( cont )
870 {
456ae26d 871 wxPrintf(_T("\t%s = %s\n"),
ee6e1b1d
VZ		 872 name.c_str(),
873 fileconf.Read(name.c_str(), _T("ERROR")).c_str());
874
875 cont = fileconf.GetNextEntry(name, dummy);
876 }
7e0777da
VZ		 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"));
ee6e1b1d
VZ		 883}
884
885#endif // TEST_FILECONF
886
844f90fb
VZ		 887// ----------------------------------------------------------------------------
888// wxFileName
889// ----------------------------------------------------------------------------
890
891#ifdef TEST_FILENAME
892
e84010cf 893#include "wx/filename.h"
844f90fb 894
e9d2bb6f 895#if 0
5bc1deeb 896static void DumpFileName(const wxChar *desc, const wxFileName& fn)
81f25632 897{
5bc1deeb
VZ		 898 wxPuts(desc);
899
81f25632
VZ		 900 wxString full = fn.GetFullPath();
901
902 wxString vol, path, name, ext;
903 wxFileName::SplitPath(full, &vol, &path, &name, &ext);
904
a5b7374f 905 wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
81f25632 906 full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
a5b7374f
VZ		 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());
9cb47ea2
VZ		 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 }
81f25632 927}
e9d2bb6f 928#endif
81f25632 929
ade35f11
VZ		 930static void TestFileNameTemp()
931{
456ae26d 932 wxPuts(_T("*** testing wxFileName temp file creation ***"));
ade35f11 933
456ae26d 934 static const wxChar *tmpprefixes[] =
ade35f11 935 {
456ae26d
VZ		 936 _T(""),
937 _T("foo"),
938 _T(".."),
939 _T("../bar"),
a2fa5040 940#ifdef __UNIX__
456ae26d
VZ		 941 _T("/tmp/foo"),
942 _T("/tmp/foo/bar"), // this one must be an error
a2fa5040 943#endif // __UNIX__
ade35f11
VZ		 944 };
945
946 for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
947 {
948 wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
2db991f4
VZ		 949 if ( path.empty() )
950 {
951 // "error" is not in upper case because it may be ok
456ae26d 952 wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
2db991f4
VZ		 953 }
954 else
ade35f11 955 {
456ae26d 956 wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
ade35f11
VZ		 957 tmpprefixes[n], path.c_str());
958
959 if ( !wxRemoveFile(path) )
960 {
456ae26d
VZ		 961 wxLogWarning(_T("Failed to remove temp file '%s'"),
962 path.c_str());
ade35f11
VZ		 963 }
964 }
965 }
966}
967
0aa29b6b
VZ		 968static void TestFileNameDirManip()
969{
970 // TODO: test AppendDir(), RemoveDir(), ...
971}
972
844f90fb
VZ		 973static void TestFileNameComparison()
974{
975 // TODO!
976}
977
978static void TestFileNameOperations()
979{
980 // TODO!
981}
982
983static void TestFileNameCwd()
984{
985 // TODO!
986}
987
988#endif // TEST_FILENAME
989
d56e2b97
VZ		 990// ----------------------------------------------------------------------------
991// wxFileName time functions
992// ----------------------------------------------------------------------------
993
994#ifdef TEST_FILETIME
995
b20edf8b
WS		 996#include "wx/filename.h"
997#include "wx/datetime.h"
d56e2b97
VZ		 998
999static void TestFileGetTimes()
1000{
1001 wxFileName fn(_T("testdata.fc"));
1002
6dbb903b
VZ		 1003 wxDateTime dtAccess, dtMod, dtCreate;
1004 if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
d56e2b97
VZ		 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());
6dbb903b
VZ		 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());
d56e2b97
VZ		 1016 }
1017}
1018
e9d2bb6f 1019#if 0
d56e2b97
VZ		 1020static void TestFileSetTimes()
1021{
1022 wxFileName fn(_T("testdata.fc"));
1023
d56e2b97
VZ		 1024 if ( !fn.Touch() )
1025 {
1026 wxPrintf(_T("ERROR: Touch() failed.\n"));
1027 }
1028}
e9d2bb6f 1029#endif
d56e2b97
VZ		 1030
1031#endif // TEST_FILETIME
1032
ec37df57
VZ		 1033// ----------------------------------------------------------------------------
1034// wxLocale
1035// ----------------------------------------------------------------------------
1036
1037#ifdef TEST_LOCALE
1038
1039#include "wx/intl.h"
1040#include "wx/utils.h" // for wxSetEnv
1041
3e231024
FM		 1042static 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()
ec37df57
VZ		 1046
1047// find the name of the language from its value
456ae26d
VZ		 1048static 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"),
ec37df57
VZ		 1282 };
1283
1284 if ( (size_t)lang < WXSIZEOF(languageNames) )
1285 return languageNames[lang];
1286 else
456ae26d 1287 return _T("INVALID");
ec37df57
VZ		 1288}
1289
1290static void TestDefaultLang()
1291{
456ae26d 1292 wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
ec37df57 1293
3e231024
FM		 1294 gs_localeDefault.Init(wxLANGUAGE_ENGLISH);
1295
ec37df57
VZ		 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
dccce9ea
VZ		 1311 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1312 wxLocale::GetSystemEncodingName().c_str(),
1313 wxLocale::GetSystemEncoding());
1314
ec37df57
VZ		 1315 for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1316 {
456ae26d 1317 const wxChar *langStr = langStrings[n];
ec37df57 1318 if ( langStr )
dccce9ea
VZ		 1319 {
1320 // FIXME: this doesn't do anything at all under Windows, we need
1321 // to create a new wxLocale!
ec37df57 1322 wxSetEnv(_T("LC_ALL"), langStr);
dccce9ea 1323 }
ec37df57
VZ		 1324
1325 int lang = gs_localeDefault.GetSystemLanguage();
456ae26d
VZ		 1326 wxPrintf(_T("Locale for '%s' is %s.\n"),
1327 langStr ? langStr : _T("system default"), GetLangName(lang));
ec37df57
VZ		 1328 }
1329}
1330
1331#endif // TEST_LOCALE
1332
696e1ea0
VZ		 1333// ----------------------------------------------------------------------------
1334// MIME types
1335// ----------------------------------------------------------------------------
1336
1337#ifdef TEST_MIME
1338
e84010cf 1339#include "wx/mimetype.h"
696e1ea0
VZ		 1340
1341static void TestMimeEnum()
1342{
a6c65e88
VZ		 1343 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1344
696e1ea0
VZ		 1345 wxArrayString mimetypes;
1346
39189b9d 1347 size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
696e1ea0 1348
456ae26d 1349 wxPrintf(_T("*** All %u known filetypes: ***\n"), count);
696e1ea0
VZ		 1350
1351 wxArrayString exts;
1352 wxString desc;
1353
1354 for ( size_t n = 0; n < count; n++ )
1355 {
39189b9d
VZ		 1356 wxFileType *filetype =
1357 wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
696e1ea0 1358 if ( !filetype )
c61f4f6d 1359 {
456ae26d 1360 wxPrintf(_T("nothing known about the filetype '%s'!\n"),
97e0ceea 1361 mimetypes[n].c_str());
696e1ea0 1362 continue;
c61f4f6d
VZ		 1363 }
1364
696e1ea0
VZ		 1365 filetype->GetDescription(&desc);
1366 filetype->GetExtensions(exts);
1367
299fcbfe
VZ		 1368 filetype->GetIcon(NULL);
1369
696e1ea0
VZ		 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
456ae26d 1378 wxPrintf(_T("\t%s: %s (%s)\n"),
54acce90 1379 mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
696e1ea0 1380 }
39189b9d 1381
e9d2bb6f 1382 wxPuts(wxEmptyString);
696e1ea0
VZ		 1383}
1384
f6bcfd97
BP		 1385static 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"),
f06ef5f4 1394 _T("picture.jpeg"),
f6bcfd97
BP		 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('.'));
39189b9d 1401 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
f6bcfd97
BP		 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,
e9d2bb6f 1414 wxFileType::MessageParameters(fname, wxEmptyString)) )
f6bcfd97 1415 cmd = _T("<no command available>");
7aeebdcd 1416 else
2b5f62a0 1417 cmd = wxString(_T('"')) + cmd + _T('"');
f6bcfd97 1418
7aeebdcd 1419 wxPrintf(_T("To open %s (%s) do %s.\n"),
f6bcfd97
BP		 1420 fname.c_str(), desc.c_str(), cmd.c_str());
1421
1422 delete ft;
1423 }
1424 }
39189b9d 1425
e9d2bb6f 1426 wxPuts(wxEmptyString);
f6bcfd97
BP		 1427}
1428
c19c2f6e
VZ		 1429// these tests were broken by wxMimeTypesManager changes, temporarily disabling
1430#if 0
1431
1432static 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
c7ce8392
VZ		 1458static void TestMimeAssociate()
1459{
1460 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1461
a6c65e88
VZ		 1462 wxFileTypeInfo ftInfo(
1463 _T("application/x-xyz"),
1464 _T("xyzview '%s'"), // open cmd
1465 _T(""), // print cmd
df0dc216
VZ		 1466 _T("XYZ File"), // description
1467 _T(".xyz"), // extensions
b61af837 1468 wxNullPtr // end of extensions
a6c65e88
VZ		 1469 );
1470 ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1471
39189b9d 1472 wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
c7ce8392
VZ		 1473 if ( !ft )
1474 {
1475 wxPuts(_T("ERROR: failed to create association!"));
1476 }
1477 else
1478 {
a6c65e88 1479 // TODO: read it back
c7ce8392
VZ		 1480 delete ft;
1481 }
39189b9d 1482
e9d2bb6f 1483 wxPuts(wxEmptyString);
c7ce8392
VZ		 1484}
1485
c19c2f6e
VZ		 1486#endif // 0
1487
696e1ea0
VZ		 1488#endif // TEST_MIME
1489
af266e5b
VZ		 1490// ----------------------------------------------------------------------------
1491// module dependencies feature
1492// ----------------------------------------------------------------------------
1493
1494#ifdef TEST_MODULE
1495
1496#include "wx/module.h"
1497
1498class wxTestModule : public wxModule
1499{
1500protected:
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
1505class wxTestModuleA : public wxTestModule
1506{
1507public:
1508 wxTestModuleA();
1509private:
1510 DECLARE_DYNAMIC_CLASS(wxTestModuleA)
1511};
1512
1513class wxTestModuleB : public wxTestModule
1514{
1515public:
1516 wxTestModuleB();
1517private:
1518 DECLARE_DYNAMIC_CLASS(wxTestModuleB)
1519};
1520
1521class wxTestModuleC : public wxTestModule
1522{
1523public:
1524 wxTestModuleC();
1525private:
1526 DECLARE_DYNAMIC_CLASS(wxTestModuleC)
1527};
1528
1529class wxTestModuleD : public wxTestModule
1530{
1531public:
1532 wxTestModuleD();
1533private:
1534 DECLARE_DYNAMIC_CLASS(wxTestModuleD)
1535};
1536
1537IMPLEMENT_DYNAMIC_CLASS(wxTestModuleC, wxModule)
1538wxTestModuleC::wxTestModuleC()
1539{
1540 AddDependency(CLASSINFO(wxTestModuleD));
1541}
1542
1543IMPLEMENT_DYNAMIC_CLASS(wxTestModuleA, wxModule)
1544wxTestModuleA::wxTestModuleA()
1545{
1546 AddDependency(CLASSINFO(wxTestModuleB));
1547 AddDependency(CLASSINFO(wxTestModuleD));
1548}
1549
1550IMPLEMENT_DYNAMIC_CLASS(wxTestModuleD, wxModule)
1551wxTestModuleD::wxTestModuleD()
1552{
1553}
1554
1555IMPLEMENT_DYNAMIC_CLASS(wxTestModuleB, wxModule)
1556wxTestModuleB::wxTestModuleB()
1557{
1558 AddDependency(CLASSINFO(wxTestModuleD));
1559 AddDependency(CLASSINFO(wxTestModuleC));
1560}
1561
1562#endif // TEST_MODULE
1563
89e60357
VZ		 1564// ----------------------------------------------------------------------------
1565// misc information functions
1566// ----------------------------------------------------------------------------
1567
1568#ifdef TEST_INFO_FUNCTIONS
1569
e84010cf 1570#include "wx/utils.h"
89e60357 1571
0219fd2f 1572#if TEST_INTERACTIVE
3a994742
VZ		 1573static void TestDiskInfo()
1574{
456ae26d 1575 wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
3a994742
VZ		 1576
1577 for ( ;; )
1578 {
456ae26d
VZ		 1579 wxChar pathname[128];
1580 wxPrintf(_T("\nEnter a directory name: "));
1581 if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
3a994742
VZ		 1582 break;
1583
1584 // kill the last '\n'
456ae26d 1585 pathname[wxStrlen(pathname) - 1] = 0;
3a994742
VZ		 1586
1587 wxLongLong total, free;
1588 if ( !wxGetDiskSpace(pathname, &total, &free) )
1589 {
1590 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1591 }
1592 else
1593 {
eadd7bd2
VZ		 1594 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1595 (total / 1024).ToString().c_str(),
1596 (free / 1024).ToString().c_str(),
3a994742
VZ		 1597 pathname);
1598 }
1599 }
1600}
0219fd2f 1601#endif // TEST_INTERACTIVE
3a994742 1602
89e60357
VZ		 1603static void TestOsInfo()
1604{
456ae26d 1605 wxPuts(_T("*** Testing OS info functions ***\n"));
89e60357
VZ		 1606
1607 int major, minor;
1608 wxGetOsVersion(&major, &minor);
456ae26d 1609 wxPrintf(_T("Running under: %s, version %d.%d\n"),
89e60357
VZ		 1610 wxGetOsDescription().c_str(), major, minor);
1611
10d878a9 1612 wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());
89e60357 1613
456ae26d 1614 wxPrintf(_T("Host name is %s (%s).\n"),
89e60357 1615 wxGetHostName().c_str(), wxGetFullHostName().c_str());
bd3277fe 1616
e9d2bb6f 1617 wxPuts(wxEmptyString);
89e60357
VZ		 1618}
1619
8bb6b2c0
VZ		 1620static 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
89e60357
VZ		 1637static void TestUserInfo()
1638{
456ae26d 1639 wxPuts(_T("*** Testing user info functions ***\n"));
89e60357 1640
456ae26d
VZ		 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());
bd3277fe 1645
e9d2bb6f 1646 wxPuts(wxEmptyString);
89e60357
VZ		 1647}
1648
1649#endif // TEST_INFO_FUNCTIONS
1650
39189b9d
VZ		 1651// ----------------------------------------------------------------------------
1652// path list
1653// ----------------------------------------------------------------------------
1654
1655#ifdef TEST_PATHLIST
1656
ee3ef281
VZ		 1657#ifdef __UNIX__
1658 #define CMD_IN_PATH _T("ls")
1659#else
1660 #define CMD_IN_PATH _T("command.com")
1661#endif
1662
39189b9d
VZ		 1663static void TestPathList()
1664{
456ae26d 1665 wxPuts(_T("*** Testing wxPathList ***\n"));
39189b9d
VZ		 1666
1667 wxPathList pathlist;
ee3ef281
VZ		 1668 pathlist.AddEnvList(_T("PATH"));
1669 wxString path = pathlist.FindValidPath(CMD_IN_PATH);
39189b9d
VZ		 1670 if ( path.empty() )
1671 {
456ae26d 1672 wxPrintf(_T("ERROR: command not found in the path.\n"));
39189b9d
VZ		 1673 }
1674 else
1675 {
456ae26d 1676 wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
39189b9d
VZ		 1677 }
1678}
1679
1680#endif // TEST_PATHLIST
1681
07a56e45
VZ		 1682// ----------------------------------------------------------------------------
1683// regular expressions
1684// ----------------------------------------------------------------------------
1685
1686#ifdef TEST_REGEX
1687
e84010cf 1688#include "wx/regex.h"
07a56e45 1689
07a56e45
VZ		 1690static void TestRegExInteractive()
1691{
1692 wxPuts(_T("*** Testing RE interactively ***"));
1693
1694 for ( ;; )
1695 {
456ae26d
VZ		 1696 wxChar pattern[128];
1697 wxPrintf(_T("\nEnter a pattern: "));
1698 if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
07a56e45
VZ		 1699 break;
1700
1701 // kill the last '\n'
456ae26d 1702 pattern[wxStrlen(pattern) - 1] = 0;
07a56e45
VZ		 1703
1704 wxRegEx re;
1705 if ( !re.Compile(pattern) )
1706 {
1707 continue;
1708 }
1709
456ae26d 1710 wxChar text[128];
07a56e45
VZ		 1711 for ( ;; )
1712 {
456ae26d
VZ		 1713 wxPrintf(_T("Enter text to match: "));
1714 if ( !wxFgets(text, WXSIZEOF(text), stdin) )
07a56e45
VZ		 1715 break;
1716
1717 // kill the last '\n'
456ae26d 1718 text[wxStrlen(text) - 1] = 0;
07a56e45
VZ		 1719
1720 if ( !re.Matches(text) )
1721 {
456ae26d 1722 wxPrintf(_T("No match.\n"));
07a56e45
VZ		 1723 }
1724 else
1725 {
456ae26d 1726 wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
07a56e45
VZ		 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
456ae26d
VZ		 1736 wxPrintf(_T("Subexpr %u matched '%s'\n"),
1737 n, wxString(text + start, len).c_str());
07a56e45
VZ		 1738 }
1739 }
1740 }
1741 }
1742}
1743
1744#endif // TEST_REGEX
1745
7aeebdcd
VZ		 1746// ----------------------------------------------------------------------------
1747// printf() tests
1748// ----------------------------------------------------------------------------
1749
1750/*
1751 NB: this stuff was taken from the glibc test suite and modified to build
be5a51fb 1752 in wxWidgets: if I read the copyright below properly, this shouldn't
7aeebdcd
VZ		 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 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
f1389d46
VZ		 1769#include "wx/longlong.h"
1770
7aeebdcd
VZ		 1771#include <float.h>
1772
1773static void rfg1 (void);
1774static void rfg2 (void);
1775
1776
1777static void
1778fmtchk (const wxChar *fmt)
1779{
1780 (void) wxPrintf(_T("%s:\t`"), fmt);
1781 (void) wxPrintf(fmt, 0x12);
1782 (void) wxPrintf(_T("'\n"));
1783}
1784
1785static void
1786fmtst1chk (const wxChar *fmt)
1787{
1788 (void) wxPrintf(_T("%s:\t`"), fmt);
1789 (void) wxPrintf(fmt, 4, 0x12);
1790 (void) wxPrintf(_T("'\n"));
1791}
1792
1793static void
1794fmtst2chk (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
e9d2bb6f
DS		 1824wxChar *PointerNull = NULL;
1825
7aeebdcd
VZ		 1826static void
1827fp_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 }
e9d2bb6f
DS		 1867 wxPrintf(_T("%10s\n"), PointerNull);
1868 wxPrintf(_T("%-10s\n"), PointerNull);
7aeebdcd
VZ		 1869}
1870
1871static void TestPrintf()
1872{
1873 static wxChar shortstr[] = _T("Hi, Z.");
f1389d46
VZ		 1874 static wxChar longstr[] = _T("Good morning, Doctor Chandra. This is Hal. \
1875I am ready for my first lesson today.");
7aeebdcd 1876 int result = 0;
e9d2bb6f 1877 wxString test_format;
7aeebdcd
VZ		 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
e9d2bb6f
DS		 1891 wxString bad_format = _T("bad format:\t\"%b\"\n");
1892 wxPrintf(bad_format.c_str());
7aeebdcd
VZ		 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);
e9d2bb6f
DS		 1902 test_format = _T("left-adjusted ZLDN:\t\"%-010ld\"\n");
1903 wxPrintf(test_format.c_str(), -123456);
7aeebdcd
VZ		 1904 wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
1905 wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
1906
e9d2bb6f
DS		 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);
7aeebdcd
VZ		 1911 wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
1912 wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
e9d2bb6f 1913 wxPrintf(_T("null string:\t\"%s\"\n"), PointerNull);
7aeebdcd
VZ		 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
e9d2bb6f
DS		 1946#ifndef __WATCOMC__
1947 // Open Watcom cause compiler error here
1948 // Error! E173: col(24) floating-point constant too small to represent
7aeebdcd 1949 wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
e9d2bb6f 1950#endif
7aeebdcd
VZ		 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
f1389d46 2003#ifdef wxLongLong_t
7aeebdcd 2004 {
f1389d46 2005 wxChar buf[200];
7aeebdcd 2006
2b5f62a0 2007 wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
f2cb8a17
JS		 2008 #if 0
2009 // for some reason below line fails under Borland
f1389d46 2010 wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
f2cb8a17 2011 #endif
7aeebdcd 2012
f1389d46 2013 if (wxStrcmp (buf, _T("40000000000")) != 0)
7aeebdcd 2014 {
f1389d46
VZ		 2015 result = 1;
2016 wxPuts (_T("\tFAILED"));
7aeebdcd 2017 }
e9d2bb6f
DS		 2018 wxUnusedVar(result);
2019 wxPuts (wxEmptyString);
7aeebdcd 2020 }
f1389d46 2021#endif // wxLongLong_t
7aeebdcd
VZ		 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
2052static void
2053rfg1 (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
2077static void
2078rfg2 (void)
2079{
2080 int prec;
2081 wxChar buf[100];
e9d2bb6f 2082 wxString test_format;
7aeebdcd
VZ		 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;
e9d2bb6f
DS		 2097 test_format = _T("%04.*o");
2098 wxSprintf (buf, test_format.c_str(), prec, 33);
7aeebdcd
VZ		 2099 if (wxStrcmp (buf, _T(" 041")) != 0)
2100 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
2101 prec = 7;
e9d2bb6f
DS		 2102 test_format = _T("%09.*u");
2103 wxSprintf (buf, test_format.c_str(), prec, 33);
7aeebdcd
VZ		 2104 if (wxStrcmp (buf, _T(" 0000033")) != 0)
2105 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 0000033"));
2106 prec = 3;
e9d2bb6f
DS		 2107 test_format = _T("%04.*x");
2108 wxSprintf (buf, test_format.c_str(), prec, 33);
7aeebdcd
VZ		 2109 if (wxStrcmp (buf, _T(" 021")) != 0)
2110 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2111 prec = 3;
e9d2bb6f
DS		 2112 test_format = _T("%04.*X");
2113 wxSprintf (buf, test_format.c_str(), prec, 33);
7aeebdcd
VZ		 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
6dfec4b8 2120// ----------------------------------------------------------------------------
7ba4fbeb 2121// registry and related stuff
6dfec4b8
VZ		 2122// ----------------------------------------------------------------------------
2123
2124// this is for MSW only
2125#ifndef __WXMSW__
7ba4fbeb 2126 #undef TEST_REGCONF
6dfec4b8
VZ		 2127 #undef TEST_REGISTRY
2128#endif
2129
7ba4fbeb
VZ		 2130#ifdef TEST_REGCONF
2131
e84010cf
GD		 2132#include "wx/confbase.h"
2133#include "wx/msw/regconf.h"
7ba4fbeb 2134
e9d2bb6f 2135#if 0
7ba4fbeb
VZ		 2136static void TestRegConfWrite()
2137{
e9d2bb6f
DS		 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"));
0aa29b6b 2143}
e9d2bb6f 2144#endif
0aa29b6b
VZ		 2145
2146static void TestRegConfRead()
2147{
bb573115 2148 wxRegConfig *config = new wxRegConfig(_T("myapp"));
0aa29b6b
VZ		 2149
2150 wxString str;
2151 long dummy;
e9d2bb6f
DS		 2152 config->SetPath(_T("/"));
2153 wxPuts(_T("Enumerating / subgroups:"));
0aa29b6b
VZ		 2154 bool bCont = config->GetFirstGroup(str, dummy);
2155 while(bCont)
2156 {
e9d2bb6f 2157 wxPuts(str);
0aa29b6b
VZ		 2158 bCont = config->GetNextGroup(str, dummy);
2159 }
7ba4fbeb
VZ		 2160}
2161
2162#endif // TEST_REGCONF
2163
6dfec4b8
VZ		 2164#ifdef TEST_REGISTRY
2165
e84010cf 2166#include "wx/msw/registry.h"
6dfec4b8
VZ		 2167
2168// I chose this one because I liked its name, but it probably only exists under
2169// NT
2170static const wxChar *TESTKEY =
2171 _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2172
2173static void TestRegistryRead()
2174{
456ae26d 2175 wxPuts(_T("*** testing registry reading ***"));
6dfec4b8
VZ		 2176
2177 wxRegKey key(TESTKEY);
456ae26d 2178 wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
6dfec4b8
VZ		 2179 if ( !key.Open() )
2180 {
456ae26d 2181 wxPuts(_T("ERROR: test key can't be opened, aborting test."));
6dfec4b8
VZ		 2182
2183 return;
2184 }
2185
2186 size_t nSubKeys, nValues;
2187 if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
2188 {
456ae26d 2189 wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
6dfec4b8
VZ		 2190 }
2191
456ae26d 2192 wxPrintf(_T("Enumerating values:\n"));
6dfec4b8
VZ		 2193
2194 long dummy;
2195 wxString value;
2196 bool cont = key.GetFirstValue(value, dummy);
2197 while ( cont )
2198 {
456ae26d 2199 wxPrintf(_T("Value '%s': type "), value.c_str());
6dfec4b8
VZ		 2200 switch ( key.GetValueType(value) )
2201 {
456ae26d
VZ		 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;
6dfec4b8
VZ		 2209 }
2210
456ae26d 2211 wxPrintf(_T(", value = "));
6dfec4b8
VZ		 2212 if ( key.IsNumericValue(value) )
2213 {
2214 long val;
2215 key.QueryValue(value, &val);
456ae26d 2216 wxPrintf(_T("%ld"), val);
6dfec4b8
VZ		 2217 }
2218 else // string
2219 {
2220 wxString val;
2221 key.QueryValue(value, val);
456ae26d 2222 wxPrintf(_T("'%s'"), val.c_str());
6dfec4b8
VZ		 2223
2224 key.QueryRawValue(value, val);
456ae26d 2225 wxPrintf(_T(" (raw value '%s')"), val.c_str());
6dfec4b8
VZ		 2226 }
2227
e9d2bb6f 2228 wxPutchar('\n');
6dfec4b8
VZ		 2229
2230 cont = key.GetNextValue(value, dummy);
2231 }
2232}
2233
6ba63600
VZ		 2234static 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
f2cb8a17 2244 key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
6ba63600 2245 key.Create();
f2cb8a17
JS		 2246 key = _T("ddxf_auto_file") ;
2247 key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
6ba63600 2248 key.Create();
f2cb8a17
JS		 2249 key = _T("ddxf_auto_file") ;
2250 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
6ba63600 2251 key.Create();
f2cb8a17
JS		 2252 key = _T("program,0") ;
2253 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
6ba63600 2254 key.Create();
f2cb8a17 2255 key = _T("program \"%1\"") ;
6ba63600 2256
f2cb8a17 2257 key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
6ba63600 2258 key.DeleteSelf();
f2cb8a17 2259 key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
6ba63600 2260 key.DeleteSelf();
f2cb8a17 2261 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
6ba63600 2262 key.DeleteSelf();
f2cb8a17 2263 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
6ba63600
VZ		 2264 key.DeleteSelf();
2265}
2266
6dfec4b8
VZ		 2267#endif // TEST_REGISTRY
2268
c66cca2a
VZ		 2269// ----------------------------------------------------------------------------
2270// scope guard
2271// ----------------------------------------------------------------------------
2272
df5168c4
MB		 2273#ifdef TEST_SCOPEGUARD
2274
c66cca2a
VZ		 2275#include "wx/scopeguard.h"
2276
2277static void function0() { puts("function0()"); }
2278static void function1(int n) { printf("function1(%d)\n", n); }
2279static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
2280
2281struct 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
2288static void TestScopeGuard()
2289{
24c8053b
RN		 2290 wxON_BLOCK_EXIT0(function0);
2291 wxON_BLOCK_EXIT1(function1, 17);
2292 wxON_BLOCK_EXIT2(function2, 3.14, 'p');
c66cca2a
VZ		 2293
2294 Object obj;
eb42e596
VZ		 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');
c66cca2a
VZ		 2298
2299 wxScopeGuard dismissed = wxMakeGuard(function0);
2300 dismissed.Dismiss();
2301}
2302
df5168c4
MB		 2303#endif
2304
2c8e4738
VZ		 2305// ----------------------------------------------------------------------------
2306// sockets
2307// ----------------------------------------------------------------------------
2308
2309#ifdef TEST_SOCKETS
2310
e84010cf
GD		 2311#include "wx/socket.h"
2312#include "wx/protocol/protocol.h"
2313#include "wx/protocol/http.h"
8e907a13
VZ		 2314
2315static void TestSocketServer()
2316{
456ae26d 2317 wxPuts(_T("*** Testing wxSocketServer ***\n"));
8e907a13 2318
ccdb23df
VZ		 2319 static const int PORT = 3000;
2320
8e907a13 2321 wxIPV4address addr;
ccdb23df 2322 addr.Service(PORT);
8e907a13
VZ		 2323
2324 wxSocketServer *server = new wxSocketServer(addr);
2325 if ( !server->Ok() )
2326 {
456ae26d 2327 wxPuts(_T("ERROR: failed to bind"));
ccdb23df
VZ		 2328
2329 return;
8e907a13 2330 }
8dfea369 2331
cab8f76e
VZ		 2332 bool quit = false;
2333 while ( !quit )
8dfea369 2334 {
456ae26d 2335 wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
8dfea369
VZ		 2336
2337 wxSocketBase *socket = server->Accept();
2338 if ( !socket )
2339 {
456ae26d 2340 wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
8dfea369
VZ		 2341 break;
2342 }
2343
456ae26d 2344 wxPuts(_T("Server: got a client."));
8dfea369 2345
ccdb23df
VZ		 2346 server->SetTimeout(60); // 1 min
2347
cab8f76e
VZ		 2348 bool close = false;
2349 while ( !close && socket->IsConnected() )
8dfea369 2350 {
ccdb23df 2351 wxString s;
456ae26d 2352 wxChar ch = _T('\0');
ccdb23df 2353 for ( ;; )
8dfea369 2354 {
ccdb23df
VZ		 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 {
456ae26d 2360 wxPuts(_T("ERROR: in wxSocket::Read."));
ccdb23df 2361 }
8dfea369 2362
ccdb23df
VZ		 2363 break;
2364 }
8dfea369 2365
ccdb23df
VZ		 2366 if ( ch == '\r' )
2367 continue;
8dfea369 2368
ccdb23df
VZ		 2369 if ( ch == '\n' )
2370 break;
8dfea369 2371
ccdb23df
VZ		 2372 s += ch;
2373 }
8dfea369 2374
ccdb23df
VZ		 2375 if ( ch != '\n' )
2376 {
2377 break;
2378 }
8dfea369 2379
456ae26d 2380 wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
cab8f76e 2381 if ( s == _T("close") )
ccdb23df 2382 {
cab8f76e 2383 wxPuts(_T("Closing connection"));
8dfea369 2384
cab8f76e 2385 close = true;
ccdb23df 2386 }
cab8f76e
VZ		 2387 else if ( s == _T("quit") )
2388 {
2389 close =
2390 quit = true;
ccdb23df 2391
cab8f76e
VZ		 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 }
8dfea369
VZ		 2400 }
2401
cab8f76e
VZ		 2402 if ( !close )
2403 {
2404 wxPuts(_T("Server: lost a client unexpectedly."));
2405 }
8dfea369 2406
ccdb23df 2407 socket->Destroy();
8dfea369 2408 }
9fc3cba7 2409
ccdb23df
VZ		 2410 // same as "delete server" but is consistent with GUI programs
2411 server->Destroy();
8e907a13 2412}
2c8e4738
VZ		 2413
2414static void TestSocketClient()
2415{
456ae26d 2416 wxPuts(_T("*** Testing wxSocketClient ***\n"));
2c8e4738 2417
be5a51fb 2418 static const wxChar *hostname = _T("www.wxwidgets.org");
8e907a13
VZ		 2419
2420 wxIPV4address addr;
2421 addr.Hostname(hostname);
2422 addr.Service(80);
2423
456ae26d 2424 wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
2c8e4738
VZ		 2425
2426 wxSocketClient client;
8e907a13 2427 if ( !client.Connect(addr) )
2c8e4738 2428 {
456ae26d 2429 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2c8e4738
VZ		 2430 }
2431 else
2432 {
456ae26d 2433 wxPrintf(_T("--- Connected to %s:%u...\n"),
8e907a13
VZ		 2434 addr.Hostname().c_str(), addr.Service());
2435
456ae26d 2436 wxChar buf[8192];
2c8e4738 2437
8e907a13
VZ		 2438 // could use simply "GET" here I suppose
2439 wxString cmdGet =
456ae26d 2440 wxString::Format(_T("GET http://%s/\r\n"), hostname);
8e907a13 2441 client.Write(cmdGet, cmdGet.length());
456ae26d 2442 wxPrintf(_T("--- Sent command '%s' to the server\n"),
8e907a13 2443 MakePrintable(cmdGet).c_str());
2c8e4738 2444 client.Read(buf, WXSIZEOF(buf));
456ae26d 2445 wxPrintf(_T("--- Server replied:\n%s"), buf);
8e907a13
VZ		 2446 }
2447}
2448
2e907fab
VZ		 2449#endif // TEST_SOCKETS
2450
b92fd37c
VZ		 2451// ----------------------------------------------------------------------------
2452// FTP
2453// ----------------------------------------------------------------------------
2454
2e907fab
VZ		 2455#ifdef TEST_FTP
2456
e84010cf 2457#include "wx/protocol/ftp.h"
2e907fab 2458
b92fd37c
VZ		 2459#define FTP_ANONYMOUS
2460
d6accb8c
FM		 2461static wxFTP *ftp;
2462
b92fd37c 2463#ifdef FTP_ANONYMOUS
456ae26d
VZ		 2464 static const wxChar *directory = _T("/pub");
2465 static const wxChar *filename = _T("welcome.msg");
b92fd37c 2466#else
456ae26d
VZ		 2467 static const wxChar *directory = _T("/etc");
2468 static const wxChar *filename = _T("issue");
b92fd37c
VZ		 2469#endif
2470
2471static bool TestFtpConnect()
8e907a13 2472{
456ae26d 2473 wxPuts(_T("*** Testing FTP connect ***"));
8e907a13 2474
d6accb8c
FM		 2475 // wxFTP cannot be a static variable as its ctor needs to access
2476 // wxWidgets internals after it has been initialized
2477 ftp = new wxFTP;
2478
b92fd37c 2479#ifdef FTP_ANONYMOUS
349c045a 2480 static const wxChar *hostname = _T("ftp.wxwidgets.org");
b92fd37c 2481
456ae26d 2482 wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
b92fd37c 2483#else // !FTP_ANONYMOUS
456ae26d 2484 static const wxChar *hostname = "localhost";
b92fd37c 2485
456ae26d
VZ		 2486 wxChar user[256];
2487 wxFgets(user, WXSIZEOF(user), stdin);
2488 user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
d6accb8c 2489 ftp->SetUser(user);
b92fd37c 2490
456ae26d
VZ		 2491 wxChar password[256];
2492 wxPrintf(_T("Password for %s: "), password);
2493 wxFgets(password, WXSIZEOF(password), stdin);
2494 password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
d6accb8c 2495 ftp->SetPassword(password);
b92fd37c 2496
456ae26d 2497 wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
b92fd37c
VZ		 2498#endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2499
d6accb8c 2500 if ( !ftp->Connect(hostname) )
b92fd37c 2501 {
456ae26d 2502 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
b92fd37c 2503
cab8f76e 2504 return false;
b92fd37c
VZ		 2505 }
2506 else
2507 {
456ae26d 2508 wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
d6accb8c
FM		 2509 hostname, ftp->Pwd().c_str());
2510 ftp->Close();
b92fd37c
VZ		 2511 }
2512
cab8f76e 2513 return true;
b92fd37c 2514}
b1229561 2515
b92fd37c
VZ		 2516// test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2517static void TestFtpWuFtpd()
2518{
2519 wxFTP ftp;
456ae26d 2520 static const wxChar *hostname = _T("ftp.eudora.com");
b1229561
VZ		 2521 if ( !ftp.Connect(hostname) )
2522 {
456ae26d 2523 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
b1229561
VZ		 2524 }
2525 else
2526 {
456ae26d 2527 static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
b1229561
VZ		 2528 wxInputStream *in = ftp.GetInputStream(filename);
2529 if ( !in )
2530 {
456ae26d 2531 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
b1229561
VZ		 2532 }
2533 else
2534 {
4c51b688 2535 size_t size = in->GetSize();
456ae26d 2536 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
b1229561 2537
456ae26d 2538 wxChar *data = new wxChar[size];
b1229561
VZ		 2539 if ( !in->Read(data, size) )
2540 {
456ae26d 2541 wxPuts(_T("ERROR: read error"));
b1229561
VZ		 2542 }
2543 else
2544 {
456ae26d 2545 wxPrintf(_T("Successfully retrieved the file.\n"));
b1229561
VZ		 2546 }
2547
2548 delete [] data;
2549 delete in;
2550 }
2551 }
b92fd37c 2552}
b1229561 2553
b92fd37c
VZ		 2554static void TestFtpList()
2555{
456ae26d 2556 wxPuts(_T("*** Testing wxFTP file listing ***\n"));
8e907a13 2557
b92fd37c 2558 // test CWD
d6accb8c 2559 if ( !ftp->ChDir(directory) )
b92fd37c 2560 {
456ae26d 2561 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
b92fd37c 2562 }
2e907fab 2563
d6accb8c 2564 wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2e907fab 2565
b92fd37c
VZ		 2566 // test NLIST and LIST
2567 wxArrayString files;
d6accb8c 2568 if ( !ftp->GetFilesList(files) )
8e907a13 2569 {
456ae26d 2570 wxPuts(_T("ERROR: failed to get NLIST of files"));
8e907a13
VZ		 2571 }
2572 else
2573 {
d6accb8c 2574 wxPrintf(_T("Brief list of files under '%s':\n"), ftp->Pwd().c_str());
b92fd37c
VZ		 2575 size_t count = files.GetCount();
2576 for ( size_t n = 0; n < count; n++ )
8e907a13 2577 {
456ae26d 2578 wxPrintf(_T("\t%s\n"), files[n].c_str());
8e907a13 2579 }
456ae26d 2580 wxPuts(_T("End of the file list"));
b92fd37c 2581 }
8e907a13 2582
d6accb8c 2583 if ( !ftp->GetDirList(files) )
b92fd37c 2584 {
456ae26d 2585 wxPuts(_T("ERROR: failed to get LIST of files"));
b92fd37c
VZ		 2586 }
2587 else
2588 {
d6accb8c 2589 wxPrintf(_T("Detailed list of files under '%s':\n"), ftp->Pwd().c_str());
b92fd37c
VZ		 2590 size_t count = files.GetCount();
2591 for ( size_t n = 0; n < count; n++ )
8e907a13 2592 {
456ae26d 2593 wxPrintf(_T("\t%s\n"), files[n].c_str());
2e907fab 2594 }
456ae26d 2595 wxPuts(_T("End of the file list"));
b92fd37c
VZ		 2596 }
2597
d6accb8c 2598 if ( !ftp->ChDir(_T("..")) )
b92fd37c 2599 {
456ae26d 2600 wxPuts(_T("ERROR: failed to cd to .."));
b92fd37c 2601 }
2e907fab 2602
d6accb8c 2603 wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
b92fd37c
VZ		 2604}
2605
2606static void TestFtpDownload()
2607{
456ae26d 2608 wxPuts(_T("*** Testing wxFTP download ***\n"));
b92fd37c
VZ		 2609
2610 // test RETR
d6accb8c 2611 wxInputStream *in = ftp->GetInputStream(filename);
b92fd37c
VZ		 2612 if ( !in )
2613 {
456ae26d 2614 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
b92fd37c
VZ		 2615 }
2616 else
2617 {
4c51b688 2618 size_t size = in->GetSize();
456ae26d 2619 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
b92fd37c
VZ		 2620 fflush(stdout);
2621
456ae26d 2622 wxChar *data = new wxChar[size];
b92fd37c 2623 if ( !in->Read(data, size) )
2e907fab 2624 {
456ae26d 2625 wxPuts(_T("ERROR: read error"));
2e907fab
VZ		 2626 }
2627 else
2628 {
456ae26d 2629 wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
8e907a13
VZ		 2630 }
2631
b92fd37c
VZ		 2632 delete [] data;
2633 delete in;
2634 }
2635}
8e907a13 2636
b92fd37c
VZ		 2637static void TestFtpFileSize()
2638{
456ae26d 2639 wxPuts(_T("*** Testing FTP SIZE command ***"));
b92fd37c 2640
d6accb8c 2641 if ( !ftp->ChDir(directory) )
b92fd37c 2642 {
456ae26d 2643 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
b92fd37c
VZ		 2644 }
2645
d6accb8c 2646 wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
b92fd37c 2647
d6accb8c 2648 if ( ftp->FileExists(filename) )
b92fd37c 2649 {
d6accb8c 2650 int size = ftp->GetFileSize(filename);
b92fd37c 2651 if ( size == -1 )
456ae26d 2652 wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
8e907a13 2653 else
456ae26d 2654 wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
b92fd37c
VZ		 2655 }
2656 else
2657 {
456ae26d 2658 wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
b92fd37c
VZ		 2659 }
2660}
2661
2662static void TestFtpMisc()
2663{
456ae26d 2664 wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
b92fd37c 2665
d6accb8c 2666 if ( ftp->SendCommand(_T("STAT")) != '2' )
b92fd37c 2667 {
456ae26d 2668 wxPuts(_T("ERROR: STAT failed"));
b92fd37c
VZ		 2669 }
2670 else
2671 {
d6accb8c 2672 wxPrintf(_T("STAT returned:\n\n%s\n"), ftp->GetLastResult().c_str());
b92fd37c
VZ		 2673 }
2674
d6accb8c 2675 if ( ftp->SendCommand(_T("HELP SITE")) != '2' )
b92fd37c 2676 {
456ae26d 2677 wxPuts(_T("ERROR: HELP SITE failed"));
b92fd37c
VZ		 2678 }
2679 else
2680 {
456ae26d 2681 wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
d6accb8c 2682 ftp->GetLastResult().c_str());
b92fd37c
VZ		 2683 }
2684}
2685
2686static void TestFtpInteractive()
2687{
456ae26d 2688 wxPuts(_T("\n*** Interactive wxFTP test ***"));
b92fd37c 2689
456ae26d 2690 wxChar buf[128];
b92fd37c
VZ		 2691
2692 for ( ;; )
2693 {
456ae26d
VZ		 2694 wxPrintf(_T("Enter FTP command: "));
2695 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
b92fd37c
VZ		 2696 break;
2697
2698 // kill the last '\n'
456ae26d 2699 buf[wxStrlen(buf) - 1] = 0;
b92fd37c
VZ		 2700
2701 // special handling of LIST and NLST as they require data connection
2702 wxString start(buf, 4);
2703 start.MakeUpper();
f2cb8a17 2704 if ( start == _T("LIST") || start == _T("NLST") )
8e907a13 2705 {
b92fd37c 2706 wxString wildcard;
456ae26d 2707 if ( wxStrlen(buf) > 4 )
b92fd37c 2708 wildcard = buf + 5;
8e907a13 2709
b92fd37c 2710 wxArrayString files;
d6accb8c 2711 if ( !ftp->GetList(files, wildcard, start == _T("LIST")) )
8e907a13 2712 {
456ae26d 2713 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
8e907a13
VZ		 2714 }
2715 else
2716 {
456ae26d 2717 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
d6accb8c 2718 start.c_str(), wildcard.c_str(), ftp->Pwd().c_str());
b92fd37c
VZ		 2719 size_t count = files.GetCount();
2720 for ( size_t n = 0; n < count; n++ )
2721 {
456ae26d 2722 wxPrintf(_T("\t%s\n"), files[n].c_str());
b92fd37c 2723 }
456ae26d 2724 wxPuts(_T("--- End of the file list"));
8e907a13 2725 }
2e907fab 2726 }
b92fd37c 2727 else // !list
2e907fab 2728 {
d6accb8c 2729 wxChar ch = ftp->SendCommand(buf);
456ae26d 2730 wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
b92fd37c
VZ		 2731 if ( ch )
2732 {
456ae26d 2733 wxPrintf(_T(" (return code %c)"), ch);
b92fd37c 2734 }
2e907fab 2735
d6accb8c 2736 wxPrintf(_T(", server reply:\n%s\n\n"), ftp->GetLastResult().c_str());
2e907fab 2737 }
2c8e4738 2738 }
b92fd37c 2739
456ae26d 2740 wxPuts(_T("\n*** done ***"));
2c8e4738
VZ		 2741}
2742
b92fd37c 2743static void TestFtpUpload()
f6bcfd97 2744{
456ae26d 2745 wxPuts(_T("*** Testing wxFTP uploading ***\n"));
f6bcfd97 2746
b92fd37c 2747 // upload a file
456ae26d
VZ		 2748 static const wxChar *file1 = _T("test1");
2749 static const wxChar *file2 = _T("test2");
d6accb8c 2750 wxOutputStream *out = ftp->GetOutputStream(file1);
b92fd37c
VZ		 2751 if ( out )
2752 {
456ae26d 2753 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
b92fd37c
VZ		 2754 out->Write("First hello", 11);
2755 delete out;
2756 }
f6bcfd97 2757
b92fd37c 2758 // send a command to check the remote file
d6accb8c 2759 if ( ftp->SendCommand(wxString(_T("STAT ")) + file1) != '2' )
f6bcfd97 2760 {
456ae26d 2761 wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
f6bcfd97
BP		 2762 }
2763 else
2764 {
456ae26d 2765 wxPrintf(_T("STAT %s returned:\n\n%s\n"),
d6accb8c 2766 file1, ftp->GetLastResult().c_str());
b92fd37c 2767 }
2e907fab 2768
d6accb8c 2769 out = ftp->GetOutputStream(file2);
b92fd37c
VZ		 2770 if ( out )
2771 {
456ae26d 2772 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
b92fd37c
VZ		 2773 out->Write("Second hello", 12);
2774 delete out;
f6bcfd97
BP		 2775 }
2776}
2777
2e907fab 2778#endif // TEST_FTP
2c8e4738 2779
eaff0f0d
VZ		 2780// ----------------------------------------------------------------------------
2781// stack backtrace
2782// ----------------------------------------------------------------------------
2783
2784#ifdef TEST_STACKWALKER
2785
74e2116a
MB		 2786#if wxUSE_STACKWALKER
2787
eaff0f0d
VZ		 2788#include "wx/stackwalk.h"
2789
2790class StackDump : public wxStackWalker
2791{
2792public:
2793 StackDump(const char *argv0)
2794 : wxStackWalker(argv0)
2795 {
2796 }
2797
5ba95b79 2798 virtual void Walk(size_t skip = 1)
eaff0f0d
VZ		 2799 {
2800 wxPuts(_T("Stack dump:"));
2801
5ba95b79 2802 wxStackWalker::Walk(skip);
eaff0f0d
VZ		 2803 }
2804
2805protected:
2806 virtual void OnStackFrame(const wxStackFrame& frame)
2807 {
bf3bf677 2808 printf("[%2d] ", (int) frame.GetLevel());
eaff0f0d
VZ		 2809
2810 wxString name = frame.GetName();
2811 if ( !name.empty() )
2812 {
bf3bf677 2813 printf("%-20.40s", (const char*)name.mb_str());
eaff0f0d
VZ		 2814 }
2815 else
2816 {
2817 printf("0x%08lx", (unsigned long)frame.GetAddress());
2818 }
2819
2820 if ( frame.HasSourceLocation() )
2821 {
2822 printf("\t%s:%d",
bf3bf677
VZ		 2823 (const char*)frame.GetFileName().mb_str(),
2824 (int)frame.GetLine());
eaff0f0d
VZ		 2825 }
2826
2827 puts("");
2828
2829 wxString type, val;
2830 for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
2831 {
3e231024
FM		 2832 printf("\t%s %s = %s\n", (const char*)type.mb_str(),
2833 (const char*)name.mb_str(),
bf3bf677 2834 (const char*)val.mb_str());
eaff0f0d
VZ		 2835 }
2836 }
2837};
2838
2839static void TestStackWalk(const char *argv0)
2840{
2841 wxPuts(_T("*** Testing wxStackWalker ***\n"));
2842
2843 StackDump dump(argv0);
2844 dump.Walk();
2845}
2846
74e2116a
MB		 2847#endif // wxUSE_STACKWALKER
2848
eaff0f0d
VZ		 2849#endif // TEST_STACKWALKER
2850
af33b199
VZ		 2851// ----------------------------------------------------------------------------
2852// standard paths
2853// ----------------------------------------------------------------------------
2854
2855#ifdef TEST_STDPATHS
2856
2857#include "wx/stdpaths.h"
6f207e66 2858#include "wx/wxchar.h" // wxPrintf
af33b199
VZ		 2859
2860static void TestStandardPaths()
2861{
2862 wxPuts(_T("*** Testing wxStandardPaths ***\n"));
2863
2864 wxTheApp->SetAppName(_T("console"));
2865
5ba95b79 2866 wxStandardPathsBase& stdp = wxStandardPaths::Get();
af33b199
VZ		 2867 wxPrintf(_T("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
2868 wxPrintf(_T("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
2869 wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
2870 wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
2871 wxPrintf(_T("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
2872 wxPrintf(_T("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
17af82fb 2873 wxPrintf(_T("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
ac7ad70d 2874 wxPrintf(_T("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
af33b199 2875 wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
3af9f2de
VZ		 2876 wxPrintf(_T("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
2877 wxPrintf(_T("Localized res. dir:\t%s\n"),
2878 stdp.GetLocalizedResourcesDir(_T("fr")).c_str());
2879 wxPrintf(_T("Message catalogs dir:\t%s\n"),
2880 stdp.GetLocalizedResourcesDir
2881 (
2882 _T("fr"),
2883 wxStandardPaths::ResourceCat_Messages
2884 ).c_str());
af33b199
VZ		 2885}
2886
2887#endif // TEST_STDPATHS
2888
83141d3a
VZ		 2889// ----------------------------------------------------------------------------
2890// streams
2891// ----------------------------------------------------------------------------
2892
2893#ifdef TEST_STREAMS
2894
e84010cf
GD		 2895#include "wx/wfstream.h"
2896#include "wx/mstream.h"
83141d3a 2897
24f25c8a
VZ		 2898static void TestFileStream()
2899{
456ae26d 2900 wxPuts(_T("*** Testing wxFileInputStream ***"));
24f25c8a 2901
e9d2bb6f 2902 static const wxString filename = _T("testdata.fs");
24f25c8a
VZ		 2903 {
2904 wxFileOutputStream fsOut(filename);
2905 fsOut.Write("foo", 3);
2906 }
2907
24f25c8a 2908 {
5df663af
VZ		 2909 wxFileInputStream fsIn(filename);
2910 wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
2911 while ( !fsIn.Eof() )
2912 {
2913 wxPutchar(fsIn.GetC());
2914 }
24f25c8a
VZ		 2915 }
2916
2917 if ( !wxRemoveFile(filename) )
2918 {
e9d2bb6f 2919 wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
24f25c8a
VZ		 2920 }
2921
456ae26d 2922 wxPuts(_T("\n*** wxFileInputStream test done ***"));
24f25c8a
VZ		 2923}
2924
83141d3a
VZ		 2925static void TestMemoryStream()
2926{
99a5af7f
VZ		 2927 wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
2928
2929 wxMemoryOutputStream memOutStream;
2930 wxPrintf(_T("Initially out stream offset: %lu\n"),
2931 (unsigned long)memOutStream.TellO());
2932
2933 for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
2934 {
2935 memOutStream.PutC(*p);
2936 }
2937
2938 wxPrintf(_T("Final out stream offset: %lu\n"),
2939 (unsigned long)memOutStream.TellO());
2940
2941 wxPuts(_T("*** Testing wxMemoryInputStream ***"));
83141d3a
VZ		 2942
2943 wxChar buf[1024];
99a5af7f 2944 size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
83141d3a 2945
99a5af7f
VZ		 2946 wxMemoryInputStream memInpStream(buf, len);
2947 wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
83141d3a
VZ		 2948 while ( !memInpStream.Eof() )
2949 {
e9d2bb6f 2950 wxPutchar(memInpStream.GetC());
83141d3a
VZ		 2951 }
2952
456ae26d 2953 wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
83141d3a
VZ		 2954}
2955
2956#endif // TEST_STREAMS
2957
d31b7b68
VZ		 2958// ----------------------------------------------------------------------------
2959// timers
2960// ----------------------------------------------------------------------------
2961
2962#ifdef TEST_TIMER
2963
5ba95b79 2964#include "wx/stopwatch.h"
e84010cf 2965#include "wx/utils.h"
d31b7b68
VZ		 2966
2967static void TestStopWatch()
2968{
456ae26d 2969 wxPuts(_T("*** Testing wxStopWatch ***\n"));
d31b7b68
VZ		 2970
2971 wxStopWatch sw;
677eff07 2972 sw.Pause();
456ae26d 2973 wxPrintf(_T("Initially paused, after 2 seconds time is..."));
677eff07
VZ		 2974 fflush(stdout);
2975 wxSleep(2);
456ae26d 2976 wxPrintf(_T("\t%ldms\n"), sw.Time());
677eff07 2977
456ae26d 2978 wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
677eff07
VZ		 2979 fflush(stdout);
2980 sw.Resume();
d31b7b68 2981 wxSleep(3);
456ae26d 2982 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
d31b7b68
VZ		 2983
2984 sw.Pause();
456ae26d 2985 wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
677eff07 2986 fflush(stdout);
d31b7b68 2987 wxSleep(2);
456ae26d 2988 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
d31b7b68
VZ		 2989
2990 sw.Resume();
456ae26d 2991 wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
677eff07
VZ		 2992 fflush(stdout);
2993 wxSleep(2);
456ae26d 2994 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
87798c00
VZ		 2995
2996 wxStopWatch sw2;
456ae26d 2997 wxPuts(_T("\nChecking for 'backwards clock' bug..."));
87798c00
VZ		 2998 for ( size_t n = 0; n < 70; n++ )
2999 {
3000 sw2.Start();
89e6463c
GRG		 3001
3002 for ( size_t m = 0; m < 100000; m++ )
87798c00 3003 {
89e6463c
GRG		 3004 if ( sw.Time() < 0 || sw2.Time() < 0 )
3005 {
456ae26d 3006 wxPuts(_T("\ntime is negative - ERROR!"));
89e6463c 3007 }
87798c00
VZ		 3008 }
3009
e9d2bb6f 3010 wxPutchar('.');
677eff07 3011 fflush(stdout);
87798c00
VZ		 3012 }
3013
456ae26d 3014 wxPuts(_T(", ok."));
d31b7b68
VZ		 3015}
3016
549b95b3
VZ		 3017#include "wx/timer.h"
3018#include "wx/evtloop.h"
3019
3020void TestTimer()
3021{
3022 wxPuts(_T("*** Testing wxTimer ***\n"));
3023
3024 class MyTimer : public wxTimer
3025 {
3026 public:
3027 MyTimer() : wxTimer() { m_num = 0; }
3028
3029 virtual void Notify()
3030 {
3031 wxPrintf(_T("%d"), m_num++);
74e10fcc 3032 fflush(stdout);
549b95b3
VZ		 3033
3034 if ( m_num == 10 )
3035 {
3036 wxPrintf(_T("... exiting the event loop"));
3037 Stop();
3038
3039 wxEventLoop::GetActive()->Exit(0);
3040 wxPuts(_T(", ok."));
3041 }
3042
3043 fflush(stdout);
3044 }
3045
3046 private:
3047 int m_num;
3048 };
3049
3050 wxEventLoop loop;
3051
74e10fcc
VZ		 3052 wxTimer timer1;
3053 timer1.Start(100, true /* one shot */);
3054 timer1.Stop();
3055 timer1.Start(100, true /* one shot */);
3056
549b95b3
VZ		 3057 MyTimer timer;
3058 timer.Start(500);
3059
3060 loop.Run();
3061}
3062
d31b7b68
VZ		 3063#endif // TEST_TIMER
3064
f6bcfd97
BP		 3065// ----------------------------------------------------------------------------
3066// vCard support
3067// ----------------------------------------------------------------------------
3068
3069#ifdef TEST_VCARD
3070
e84010cf 3071#include "wx/vcard.h"
f6bcfd97
BP		 3072
3073static void DumpVObject(size_t level, const wxVCardObject& vcard)
3074{
3075 void *cookie;
3076 wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3077 while ( vcObj )
3078 {
456ae26d 3079 wxPrintf(_T("%s%s"),
f6bcfd97
BP		 3080 wxString(_T('\t'), level).c_str(),
3081 vcObj->GetName().c_str());
3082
3083 wxString value;
3084 switch ( vcObj->GetType() )
3085 {
3086 case wxVCardObject::String:
3087 case wxVCardObject::UString:
3088 {
3089 wxString val;
3090 vcObj->GetValue(&val);
3091 value << _T('"') << val << _T('"');
3092 }
3093 break;
3094
3095 case wxVCardObject::Int:
3096 {
3097 unsigned int i;
3098 vcObj->GetValue(&i);
3099 value.Printf(_T("%u"), i);
3100 }
3101 break;
3102
3103 case wxVCardObject::Long:
3104 {
3105 unsigned long l;
3106 vcObj->GetValue(&l);
3107 value.Printf(_T("%lu"), l);
3108 }
3109 break;
3110
3111 case wxVCardObject::None:
3112 break;
3113
3114 case wxVCardObject::Object:
3115 value = _T("<node>");
3116 break;
3117
3118 default:
3119 value = _T("<unknown value type>");
3120 }
3121
3122 if ( !!value )
456ae26d 3123 wxPrintf(_T(" = %s"), value.c_str());
e9d2bb6f 3124 wxPutchar('\n');
f6bcfd97
BP		 3125
3126 DumpVObject(level + 1, *vcObj);
3127
3128 delete vcObj;
3129 vcObj = vcard.GetNextProp(&cookie);
3130 }
3131}
3132
3133static void DumpVCardAddresses(const wxVCard& vcard)
3134{
456ae26d 3135 wxPuts(_T("\nShowing all addresses from vCard:\n"));
f6bcfd97
BP		 3136
3137 size_t nAdr = 0;
3138 void *cookie;
3139 wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3140 while ( addr )
3141 {
3142 wxString flagsStr;
3143 int flags = addr->GetFlags();
3144 if ( flags & wxVCardAddress::Domestic )
3145 {
3146 flagsStr << _T("domestic ");
3147 }
3148 if ( flags & wxVCardAddress::Intl )
3149 {
3150 flagsStr << _T("international ");
3151 }
3152 if ( flags & wxVCardAddress::Postal )
3153 {
3154 flagsStr << _T("postal ");
3155 }
3156 if ( flags & wxVCardAddress::Parcel )
3157 {
3158 flagsStr << _T("parcel ");
3159 }
3160 if ( flags & wxVCardAddress::Home )
3161 {
3162 flagsStr << _T("home ");
3163 }
3164 if ( flags & wxVCardAddress::Work )
3165 {
3166 flagsStr << _T("work ");
3167 }
3168
456ae26d 3169 wxPrintf(_T("Address %u:\n")
f6bcfd97
BP		 3170 "\tflags = %s\n"
3171 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3172 ++nAdr,
3173 flagsStr.c_str(),
3174 addr->GetPostOffice().c_str(),
3175 addr->GetExtAddress().c_str(),
3176 addr->GetStreet().c_str(),
3177 addr->GetLocality().c_str(),
3178 addr->GetRegion().c_str(),
3179 addr->GetPostalCode().c_str(),
3180 addr->GetCountry().c_str()
3181 );
3182
3183 delete addr;
3184 addr = vcard.GetNextAddress(&cookie);
3185 }
3186}
3187
3188static void DumpVCardPhoneNumbers(const wxVCard& vcard)
3189{
456ae26d 3190 wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
f6bcfd97
BP		 3191
3192 size_t nPhone = 0;
3193 void *cookie;
3194 wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
3195 while ( phone )
3196 {
3197 wxString flagsStr;
3198 int flags = phone->GetFlags();
3199 if ( flags & wxVCardPhoneNumber::Voice )
3200 {
3201 flagsStr << _T("voice ");
3202 }
3203 if ( flags & wxVCardPhoneNumber::Fax )
3204 {
3205 flagsStr << _T("fax ");
3206 }
3207 if ( flags & wxVCardPhoneNumber::Cellular )
3208 {
3209 flagsStr << _T("cellular ");
3210 }
3211 if ( flags & wxVCardPhoneNumber::Modem )
3212 {
3213 flagsStr << _T("modem ");
3214 }
3215 if ( flags & wxVCardPhoneNumber::Home )
3216 {
3217 flagsStr << _T("home ");
3218 }
3219 if ( flags & wxVCardPhoneNumber::Work )
3220 {
3221 flagsStr << _T("work ");
3222 }
3223
456ae26d 3224 wxPrintf(_T("Phone number %u:\n")
f6bcfd97
BP		 3225 "\tflags = %s\n"
3226 "\tvalue = %s\n",
3227 ++nPhone,
3228 flagsStr.c_str(),
3229 phone->GetNumber().c_str()
3230 );
3231
3232 delete phone;
3233 phone = vcard.GetNextPhoneNumber(&cookie);
3234 }
3235}
3236
3237static void TestVCardRead()
3238{
456ae26d 3239 wxPuts(_T("*** Testing wxVCard reading ***\n"));
f6bcfd97
BP		 3240
3241 wxVCard vcard(_T("vcard.vcf"));
3242 if ( !vcard.IsOk() )
3243 {
456ae26d 3244 wxPuts(_T("ERROR: couldn't load vCard."));
f6bcfd97
BP		 3245 }
3246 else
3247 {
3248 // read individual vCard properties
3249 wxVCardObject *vcObj = vcard.GetProperty("FN");
3250 wxString value;
3251 if ( vcObj )
3252 {
3253 vcObj->GetValue(&value);
3254 delete vcObj;
3255 }
3256 else
3257 {
3258 value = _T("<none>");
3259 }
3260
456ae26d 3261 wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
f6bcfd97
BP		 3262
3263
3264 if ( !vcard.GetFullName(&value) )
3265 {
3266 value = _T("<none>");
3267 }
3268
456ae26d 3269 wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
f6bcfd97 3270
3103e8a9 3271 // now show how to deal with multiply occurring properties
f6bcfd97
BP		 3272 DumpVCardAddresses(vcard);
3273 DumpVCardPhoneNumbers(vcard);
3274
3275 // and finally show all
456ae26d 3276 wxPuts(_T("\nNow dumping the entire vCard:\n")
f6bcfd97
BP		 3277 "-----------------------------\n");
3278
3279 DumpVObject(0, vcard);
3280 }
3281}
3282
3283static void TestVCardWrite()
3284{
456ae26d 3285 wxPuts(_T("*** Testing wxVCard writing ***\n"));
f6bcfd97
BP		 3286
3287 wxVCard vcard;
3288 if ( !vcard.IsOk() )
3289 {
456ae26d 3290 wxPuts(_T("ERROR: couldn't create vCard."));
f6bcfd97
BP		 3291 }
3292 else
3293 {
3294 // set some fields
3295 vcard.SetName("Zeitlin", "Vadim");
3296 vcard.SetFullName("Vadim Zeitlin");
be5a51fb 3297 vcard.SetOrganization("wxWidgets", "R&D");
f6bcfd97
BP		 3298
3299 // just dump the vCard back
456ae26d
VZ		 3300 wxPuts(_T("Entire vCard follows:\n"));
3301 wxPuts(vcard.Write());
f6bcfd97
BP		 3302 }
3303}
3304
3305#endif // TEST_VCARD
3306
0e2c5534
VZ		 3307// ----------------------------------------------------------------------------
3308// wxVolume tests
3309// ----------------------------------------------------------------------------
3310
ba6ea19e 3311#if !defined(__WIN32__) || !wxUSE_FSVOLUME
0e2c5534
VZ		 3312 #undef TEST_VOLUME
3313#endif
3314
3315#ifdef TEST_VOLUME
3316
3317#include "wx/volume.h"
3318
3319static const wxChar *volumeKinds[] =
3320{
3321 _T("floppy"),
3322 _T("hard disk"),
3323 _T("CD-ROM"),
3324 _T("DVD-ROM"),
3325 _T("network volume"),
3326 _T("other volume"),
3327};
3328
3329static void TestFSVolume()
3330{
3331 wxPuts(_T("*** Testing wxFSVolume class ***"));
3332
3333 wxArrayString volumes = wxFSVolume::GetVolumes();
3334 size_t count = volumes.GetCount();
3335
3336 if ( !count )
3337 {
3338 wxPuts(_T("ERROR: no mounted volumes?"));
3339 return;
3340 }
3341
3342 wxPrintf(_T("%u mounted volumes found:\n"), count);
3343
3344 for ( size_t n = 0; n < count; n++ )
3345 {
3346 wxFSVolume vol(volumes[n]);
3347 if ( !vol.IsOk() )
3348 {
3349 wxPuts(_T("ERROR: couldn't create volume"));
3350 continue;
3351 }
3352
3353 wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3354 n + 1,
3355 vol.GetDisplayName().c_str(),
3356 vol.GetName().c_str(),
3357 volumeKinds[vol.GetKind()],
3358 vol.IsWritable() ? _T("rw") : _T("ro"),
3359 vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3360 : _T("fixed"));
3361 }
3362}
3363
3364#endif // TEST_VOLUME
3365
f6bcfd97 3366// ----------------------------------------------------------------------------
e7d41190 3367// wide char and Unicode support
f6bcfd97
BP		 3368// ----------------------------------------------------------------------------
3369
3370#ifdef TEST_WCHAR
3371
e84010cf
GD		 3372#include "wx/strconv.h"
3373#include "wx/fontenc.h"
3374#include "wx/encconv.h"
3375#include "wx/buffer.h"
f6bcfd97 3376
2b5f62a0 3377static const unsigned char utf8koi8r[] =
ac511156
VZ		 3378{
3379 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3380 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3381 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3382 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3383 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3384 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3385 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3386};
3387
2b5f62a0
VZ		 3388static const unsigned char utf8iso8859_1[] =
3389{
3390 0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3391 0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3392 0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3393 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3394 0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3395};
3396
3397static const unsigned char utf8Invalid[] =
3398{
3399 0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3400 0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3401 0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3402 0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3403 0x6c, 0x61, 0x79, 0
3404};
3405
3406static const struct Utf8Data
3407{
3408 const unsigned char *text;
3409 size_t len;
3410 const wxChar *charset;
3411 wxFontEncoding encoding;
3412} utf8data[] =
3413{
3414 { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3415 { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3416 { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3417};
456ae26d 3418
f6bcfd97
BP		 3419static void TestUtf8()
3420{
456ae26d 3421 wxPuts(_T("*** Testing UTF8 support ***\n"));
f6bcfd97 3422
24f25c8a
VZ		 3423 char buf[1024];
3424 wchar_t wbuf[1024];
2b5f62a0
VZ		 3425
3426 for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
24f25c8a 3427 {
2b5f62a0
VZ		 3428 const Utf8Data& u8d = utf8data[n];
3429 if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3430 WXSIZEOF(wbuf)) == (size_t)-1 )
24f25c8a 3431 {
2b5f62a0 3432 wxPuts(_T("ERROR: UTF-8 decoding failed."));
24f25c8a
VZ		 3433 }
3434 else
ac511156 3435 {
2b5f62a0
VZ		 3436 wxCSConv conv(u8d.charset);
3437 if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3438 {
3439 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3440 }
3441 else
3442 {
3443 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3444 }
ac511156 3445 }
ac511156 3446
5bc1deeb 3447 wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
2b5f62a0
VZ		 3448 if ( s.empty() )
3449 s = _T("<< conversion failed >>");
3450 wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3451
ac511156
VZ		 3452 }
3453
e9d2bb6f 3454 wxPuts(wxEmptyString);
ac511156 3455}
f6bcfd97 3456
ac511156
VZ		 3457static void TestEncodingConverter()
3458{
3459 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3460
3461 // using wxEncodingConverter should give the same result as above
3462 char buf[1024];
3463 wchar_t wbuf[1024];
2b5f62a0
VZ		 3464 if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
3465 WXSIZEOF(utf8koi8r)) == (size_t)-1 )
ac511156 3466 {
456ae26d 3467 wxPuts(_T("ERROR: UTF-8 decoding failed."));
ac511156
VZ		 3468 }
3469 else
3470 {
3471 wxEncodingConverter ec;
3472 ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3473 ec.Convert(wbuf, buf);
2b5f62a0 3474 wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
24f25c8a 3475 }
ac511156 3476
e9d2bb6f 3477 wxPuts(wxEmptyString);
f6bcfd97
BP		 3478}
3479
3480#endif // TEST_WCHAR
3481
3482// ----------------------------------------------------------------------------
3483// ZIP stream
3484// ----------------------------------------------------------------------------
3485
3486#ifdef TEST_ZIP
3487
2ca8b884
VZ		 3488#include "wx/filesys.h"
3489#include "wx/fs_zip.h"
f6bcfd97
BP		 3490#include "wx/zipstrm.h"
3491
2ca8b884
VZ		 3492static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3493
f6bcfd97
BP		 3494static void TestZipStreamRead()
3495{
456ae26d 3496 wxPuts(_T("*** Testing ZIP reading ***\n"));
f6bcfd97 3497
e9d2bb6f 3498 static const wxString filename = _T("foo");
bf3bf677 3499 wxFFileInputStream in(TESTFILE_ZIP);
3e231024 3500 wxZipInputStream istr(in);
bf3bf677
VZ		 3501 wxZipEntry entry(filename);
3502 istr.OpenEntry(entry);
3503
456ae26d 3504 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
f6bcfd97 3505
e9d2bb6f 3506 wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
f6bcfd97
BP		 3507 while ( !istr.Eof() )
3508 {
e9d2bb6f 3509 wxPutchar(istr.GetC());
f6bcfd97
BP		 3510 fflush(stdout);
3511 }
3512
456ae26d 3513 wxPuts(_T("\n----- done ------"));
f6bcfd97
BP		 3514}
3515
2ca8b884
VZ		 3516static void DumpZipDirectory(wxFileSystem& fs,
3517 const wxString& dir,
3518 const wxString& indent)
3519{
3520 wxString prefix = wxString::Format(_T("%s#zip:%s"),
3521 TESTFILE_ZIP, dir.c_str());
3522 wxString wildcard = prefix + _T("/*");
3523
3524 wxString dirname = fs.FindFirst(wildcard, wxDIR);
3525 while ( !dirname.empty() )
3526 {
3527 if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3528 {
3529 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3530
3531 break;
3532 }
3533
3534 wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3535
3536 DumpZipDirectory(fs, dirname,
3537 indent + wxString(_T(' '), 4));
3538
3539 dirname = fs.FindNext();
3540 }
3541
3542 wxString filename = fs.FindFirst(wildcard, wxFILE);
3543 while ( !filename.empty() )
3544 {
3545 if ( !filename.StartsWith(prefix, &filename) )
3546 {
3547 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3548
3549 break;
3550 }
3551
3552 wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3553
3554 filename = fs.FindNext();
3555 }
3556}
3557
3558static void TestZipFileSystem()
3559{
456ae26d 3560 wxPuts(_T("*** Testing ZIP file system ***\n"));
2ca8b884
VZ		 3561
3562 wxFileSystem::AddHandler(new wxZipFSHandler);
3563 wxFileSystem fs;
3564 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3565
3566 DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3567}
3568
f6bcfd97
BP		 3569#endif // TEST_ZIP
3570
b76b015e
VZ		 3571// ----------------------------------------------------------------------------
3572// date time
3573// ----------------------------------------------------------------------------
3574
d31b7b68 3575#ifdef TEST_DATETIME
b76b015e 3576
b713f891 3577#include "wx/math.h"
e84010cf 3578#include "wx/datetime.h"
b76b015e 3579
2f02cb89 3580// this test miscellaneous static wxDateTime functions
4b586201
WS		 3581
3582#if TEST_ALL
3583
2f02cb89
VZ		 3584static void TestTimeStatic()
3585{
456ae26d 3586 wxPuts(_T("\n*** wxDateTime static methods test ***"));
2f02cb89
VZ		 3587
3588 // some info about the current date
3589 int year = wxDateTime::GetCurrentYear();
456ae26d 3590 wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
2f02cb89
VZ		 3591 year,
3592 wxDateTime::IsLeapYear(year) ? "" : "not ",
3593 wxDateTime::GetNumberOfDays(year));
3594
3595 wxDateTime::Month month = wxDateTime::GetCurrentMonth();
456ae26d 3596 wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
f0f951fa 3597 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
2f02cb89
VZ		 3598 wxDateTime::GetMonthName(month).c_str(),
3599 wxDateTime::GetNumberOfDays(month));
2f02cb89
VZ		 3600}
3601
fcc3d7cb
VZ		 3602// test time zones stuff
3603static void TestTimeZones()
3604{
456ae26d 3605 wxPuts(_T("\n*** wxDateTime timezone test ***"));
fcc3d7cb
VZ		 3606
3607 wxDateTime now = wxDateTime::Now();
3608
456ae26d
VZ		 3609 wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
3610 wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
3611 wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
3612 wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
3613 wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
3614 wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
9d9b7755 3615
ccd6aacd
VZ		 3616 wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3617
9d9b7755
VZ		 3618 wxDateTime::Tm tm = now.GetTm();
3619 if ( wxDateTime(tm) != now )
3620 {
456ae26d
VZ		 3621 wxPrintf(_T("ERROR: got %s instead of %s\n"),
3622 wxDateTime(tm).Format().c_str(), now.Format().c_str());
9d9b7755 3623 }
fcc3d7cb
VZ		 3624}
3625
e6ec579c
VZ		 3626// test some minimal support for the dates outside the standard range
3627static void TestTimeRange()
3628{
456ae26d 3629 wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
e6ec579c 3630
456ae26d 3631 static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
211c2250 3632
456ae26d
VZ		 3633 wxPrintf(_T("Unix epoch:\t%s\n"),
3634 wxDateTime(2440587.5).Format(fmt).c_str());
3635 wxPrintf(_T("Feb 29, 0: \t%s\n"),
3636 wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3637 wxPrintf(_T("JDN 0: \t%s\n"),
3638 wxDateTime(0.0).Format(fmt).c_str());
3639 wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3640 wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3641 wxPrintf(_T("May 29, 2099:\t%s\n"),
3642 wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
e6ec579c
VZ		 3643}
3644
239446b4
VZ		 3645// test DST calculations
3646static void TestTimeDST()
3647{
456ae26d 3648 wxPuts(_T("\n*** wxDateTime DST test ***"));
239446b4 3649
456ae26d 3650 wxPrintf(_T("DST is%s in effect now.\n\n"),
e9d2bb6f 3651 wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
239446b4 3652
ccd6aacd 3653 for ( int year = 1990; year < 2005; year++ )
239446b4 3654 {
456ae26d
VZ		 3655 wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3656 year,
3657 wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3658 wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
239446b4
VZ		 3659 }
3660}
3661
4b586201
WS		 3662#endif // TEST_ALL
3663
3664#if TEST_INTERACTIVE
3665
b92fd37c 3666static void TestDateTimeInteractive()
9d9b7755 3667{
456ae26d 3668 wxPuts(_T("\n*** interactive wxDateTime tests ***"));
9d9b7755 3669
456ae26d 3670 wxChar buf[128];
9d9b7755
VZ		 3671
3672 for ( ;; )
3673 {
456ae26d
VZ		 3674 wxPrintf(_T("Enter a date: "));
3675 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
9d9b7755
VZ		 3676 break;
3677
f6bcfd97 3678 // kill the last '\n'
456ae26d 3679 buf[wxStrlen(buf) - 1] = 0;
f6bcfd97 3680
9d9b7755 3681 wxDateTime dt;
456ae26d 3682 const wxChar *p = dt.ParseDate(buf);
f6bcfd97 3683 if ( !p )
9d9b7755 3684 {
456ae26d 3685 wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
9d9b7755
VZ		 3686
3687 continue;
3688 }
f6bcfd97
BP		 3689 else if ( *p )
3690 {
456ae26d 3691 wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
f6bcfd97 3692 }
9d9b7755 3693
456ae26d
VZ		 3694 wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3695 dt.Format(_T("%b %d, %Y")).c_str(),
3696 dt.GetDayOfYear(),
3697 dt.GetWeekOfMonth(wxDateTime::Monday_First),
3698 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3699 dt.GetWeekOfYear(wxDateTime::Monday_First));
9d9b7755
VZ		 3700 }
3701
456ae26d 3702 wxPuts(_T("\n*** done ***"));
9d9b7755
VZ		 3703}
3704
4b586201
WS		 3705#endif // TEST_INTERACTIVE
3706
3707#if TEST_ALL
3708
f6bcfd97
BP		 3709static void TestTimeMS()
3710{
456ae26d 3711 wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
f6bcfd97
BP		 3712
3713 wxDateTime dt1 = wxDateTime::Now(),
3714 dt2 = wxDateTime::UNow();
3715
456ae26d
VZ		 3716 wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
3717 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3718 wxPrintf(_T("Dummy loop: "));
3ca6a5f0
BP		 3719 for ( int i = 0; i < 6000; i++ )
3720 {
3721 //for ( int j = 0; j < 10; j++ )
3722 {
3723 wxString s;
ccd6aacd 3724 s.Printf(_T("%g"), sqrt((float)i));
3ca6a5f0
BP		 3725 }
3726
3727 if ( !(i % 100) )
e9d2bb6f 3728 wxPutchar('.');
3ca6a5f0 3729 }
456ae26d 3730 wxPuts(_T(", done"));
3ca6a5f0
BP		 3731
3732 dt1 = dt2;
3733 dt2 = wxDateTime::UNow();
456ae26d 3734 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3ca6a5f0 3735
456ae26d 3736 wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
f6bcfd97 3737
456ae26d 3738 wxPuts(_T("\n*** done ***"));
f6bcfd97
BP		 3739}
3740
0de868d9
VZ		 3741static void TestTimeHolidays()
3742{
456ae26d 3743 wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
0de868d9
VZ		 3744
3745 wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3746 wxDateTime dtStart(1, tm.mon, tm.year),
3747 dtEnd = dtStart.GetLastMonthDay();
3748
3749 wxDateTimeArray hol;
3750 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3751
456ae26d 3752 const wxChar *format = _T("%d-%b-%Y (%a)");
0de868d9 3753
456ae26d 3754 wxPrintf(_T("All holidays between %s and %s:\n"),
0de868d9
VZ		 3755 dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3756
3757 size_t count = hol.GetCount();
3758 for ( size_t n = 0; n < count; n++ )
3759 {
456ae26d 3760 wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
0de868d9
VZ		 3761 }
3762
e9d2bb6f 3763 wxPuts(wxEmptyString);
0de868d9
VZ		 3764}
3765
f6bcfd97
BP		 3766static void TestTimeZoneBug()
3767{
456ae26d 3768 wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
f6bcfd97
BP		 3769
3770 wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3771 for ( int i = 0; i < 31; i++ )
3772 {
456ae26d 3773 wxPrintf(_T("Date %s: week day %s.\n"),
f6bcfd97
BP		 3774 date.Format(_T("%d-%m-%Y")).c_str(),
3775 date.GetWeekDayName(date.GetWeekDay()).c_str());
3776
3777 date += wxDateSpan::Day();
3778 }
3779
e9d2bb6f 3780 wxPuts(wxEmptyString);
f6bcfd97
BP		 3781}
3782
df05cdc5
VZ		 3783static void TestTimeSpanFormat()
3784{
456ae26d 3785 wxPuts(_T("\n*** wxTimeSpan tests ***"));
df05cdc5 3786
456ae26d 3787 static const wxChar *formats[] =
df05cdc5
VZ		 3788 {
3789 _T("(default) %H:%M:%S"),
3790 _T("%E weeks and %D days"),
3791 _T("%l milliseconds"),
3792 _T("(with ms) %H:%M:%S:%l"),
3793 _T("100%% of minutes is %M"), // test "%%"
3794 _T("%D days and %H hours"),
a8625337 3795 _T("or also %S seconds"),
df05cdc5
VZ		 3796 };
3797
3798 wxTimeSpan ts1(1, 2, 3, 4),
3799 ts2(111, 222, 333);
3800 for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3801 {
456ae26d 3802 wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
df05cdc5
VZ		 3803 ts1.Format(formats[n]).c_str(),
3804 ts2.Format(formats[n]).c_str());
3805 }
3806
e9d2bb6f 3807 wxPuts(wxEmptyString);
df05cdc5
VZ		 3808}
3809
4b586201
WS		 3810#endif // TEST_ALL
3811
d31b7b68 3812#endif // TEST_DATETIME
b76b015e 3813
39937656
VZ		 3814// ----------------------------------------------------------------------------
3815// wxTextInput/OutputStream
3816// ----------------------------------------------------------------------------
3817
3818#ifdef TEST_TEXTSTREAM
3819
3820#include "wx/txtstrm.h"
3821#include "wx/wfstream.h"
3822
3823static void TestTextInputStream()
3824{
3825 wxPuts(_T("\n*** wxTextInputStream test ***"));
3826
e9d2bb6f
DS		 3827 wxString filename = _T("testdata.fc");
3828 wxFileInputStream fsIn(filename);
39937656
VZ		 3829 if ( !fsIn.Ok() )
3830 {
3831 wxPuts(_T("ERROR: couldn't open file."));
3832 }
3833 else
3834 {
3835 wxTextInputStream tis(fsIn);
3836
3837 size_t line = 1;
3838 for ( ;; )
3839 {
3840 const wxString s = tis.ReadLine();
3841
3842 // line could be non empty if the last line of the file isn't
3843 // terminated with EOL
3844 if ( fsIn.Eof() && s.empty() )
3845 break;
3846
3847 wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
3848 }
3849 }
3850}
3851
3852#endif // TEST_TEXTSTREAM
3853
e87271f3
VZ		 3854// ----------------------------------------------------------------------------
3855// threads
3856// ----------------------------------------------------------------------------
3857
3858#ifdef TEST_THREADS
3859
e84010cf 3860#include "wx/thread.h"
37667812 3861
bbfa0322
VZ		 3862static size_t gs_counter = (size_t)-1;
3863static wxCriticalSection gs_critsect;
c112e100 3864static wxSemaphore gs_cond;
bbfa0322 3865
b568d04f 3866class MyJoinableThread : public wxThread
bbfa0322
VZ		 3867{
3868public:
b568d04f
VZ		 3869 MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3870 { m_n = n; Create(); }
bbfa0322
VZ		 3871
3872 // thread execution starts here
b568d04f 3873 virtual ExitCode Entry();
bbfa0322 3874
b568d04f
VZ		 3875private:
3876 size_t m_n;
bbfa0322
VZ		 3877};
3878
b568d04f 3879wxThread::ExitCode MyJoinableThread::Entry()
bbfa0322 3880{
b568d04f
VZ		 3881 unsigned long res = 1;
3882 for ( size_t n = 1; n < m_n; n++ )
3883 {
3884 res *= n;
3885
3886 // it's a loooong calculation :-)
3887 Sleep(100);
3888 }
bbfa0322 3889
b568d04f 3890 return (ExitCode)res;
bbfa0322
VZ		 3891}
3892
b568d04f
VZ		 3893class MyDetachedThread : public wxThread
3894{
3895public:
456ae26d 3896 MyDetachedThread(size_t n, wxChar ch)
fcc3d7cb
VZ		 3897 {
3898 m_n = n;
3899 m_ch = ch;
cab8f76e 3900 m_cancelled = false;
fcc3d7cb
VZ		 3901
3902 Create();
3903 }
b568d04f
VZ		 3904
3905 // thread execution starts here
3906 virtual ExitCode Entry();
3907
3908 // and stops here
3909 virtual void OnExit();
3910
3911private:
9fc3ad34 3912 size_t m_n; // number of characters to write
456ae26d 3913 wxChar m_ch; // character to write
fcc3d7cb 3914
cab8f76e 3915 bool m_cancelled; // false if we exit normally
b568d04f
VZ		 3916};
3917
3918wxThread::ExitCode MyDetachedThread::Entry()
bbfa0322
VZ		 3919{
3920 {
3921 wxCriticalSectionLocker lock(gs_critsect);
3922 if ( gs_counter == (size_t)-1 )
3923 gs_counter = 1;
3924 else
3925 gs_counter++;
3926 }
3927
9fc3ad34 3928 for ( size_t n = 0; n < m_n; n++ )
bbfa0322
VZ		 3929 {
3930 if ( TestDestroy() )
fcc3d7cb 3931 {
cab8f76e 3932 m_cancelled = true;
fcc3d7cb 3933
bbfa0322 3934 break;
fcc3d7cb 3935 }
bbfa0322 3936
e9d2bb6f 3937 wxPutchar(m_ch);
bbfa0322
VZ		 3938 fflush(stdout);
3939
3940 wxThread::Sleep(100);
3941 }
3942
b568d04f 3943 return 0;
bbfa0322
VZ		 3944}
3945
b568d04f 3946void MyDetachedThread::OnExit()
bbfa0322 3947{
456ae26d 3948 wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
9fc3ad34 3949
bbfa0322 3950 wxCriticalSectionLocker lock(gs_critsect);
fcc3d7cb 3951 if ( !--gs_counter && !m_cancelled )
c112e100 3952 gs_cond.Post();
bbfa0322
VZ		 3953}
3954
2f2f3e2a 3955static void TestDetachedThreads()
9fc3ad34 3956{
456ae26d 3957 wxPuts(_T("\n*** Testing detached threads ***"));
9fc3ad34
VZ		 3958
3959 static const size_t nThreads = 3;
3960 MyDetachedThread *threads[nThreads];
3961 size_t n;
3962 for ( n = 0; n < nThreads; n++ )
3963 {
3964 threads[n] = new MyDetachedThread(10, 'A' + n);
3965 }
3966
3967 threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
3968 threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
3969
3970 for ( n = 0; n < nThreads; n++ )
3971 {
3972 threads[n]->Run();
3973 }
3974
3975 // wait until all threads terminate
3976 gs_cond.Wait();
3977
e9d2bb6f 3978 wxPuts(wxEmptyString);
9fc3ad34
VZ		 3979}
3980
2f2f3e2a 3981static void TestJoinableThreads()
9fc3ad34 3982{
456ae26d 3983 wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
9fc3ad34
VZ		 3984
3985 // calc 10! in the background
3986 MyJoinableThread thread(10);
3987 thread.Run();
3988
456ae26d 3989 wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
5bc1deeb 3990 (unsigned long)thread.Wait());
9fc3ad34
VZ		 3991}
3992
2f2f3e2a 3993static void TestThreadSuspend()
9fc3ad34 3994{
456ae26d 3995 wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
2f02cb89
VZ		 3996
3997 MyDetachedThread *thread = new MyDetachedThread(15, 'X');
9fc3ad34
VZ		 3998
3999 thread->Run();
4000
4001 // this is for this demo only, in a real life program we'd use another
4002 // condition variable which would be signaled from wxThread::Entry() to
4003 // tell us that the thread really started running - but here just wait a
4004 // bit and hope that it will be enough (the problem is, of course, that
4005 // the thread might still not run when we call Pause() which will result
4006 // in an error)
4007 wxThread::Sleep(300);
4008
4009 for ( size_t n = 0; n < 3; n++ )
4010 {
4011 thread->Pause();
4012
456ae26d 4013 wxPuts(_T("\nThread suspended"));
9fc3ad34
VZ		 4014 if ( n > 0 )
4015 {
4016 // don't sleep but resume immediately the first time
4017 wxThread::Sleep(300);
4018 }
456ae26d 4019 wxPuts(_T("Going to resume the thread"));
9fc3ad34
VZ		 4020
4021 thread->Resume();
4022 }
4023
456ae26d 4024 wxPuts(_T("Waiting until it terminates now"));
4c460b34 4025
9fc3ad34
VZ		 4026 // wait until the thread terminates
4027 gs_cond.Wait();
4028
e9d2bb6f 4029 wxPuts(wxEmptyString);
9fc3ad34
VZ		 4030}
4031
2f2f3e2a 4032static void TestThreadDelete()
2f02cb89
VZ		 4033{
4034 // As above, using Sleep() is only for testing here - we must use some
4035 // synchronisation object instead to ensure that the thread is still
4036 // running when we delete it - deleting a detached thread which already
4037 // terminated will lead to a crash!
4038
456ae26d 4039 wxPuts(_T("\n*** Testing thread delete function ***"));
2f02cb89 4040
4c460b34
VZ		 4041 MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
4042
4043 thread0->Delete();
4044
456ae26d 4045 wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
4c460b34 4046
2f02cb89
VZ		 4047 MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
4048
4049 thread1->Run();
4050
4051 wxThread::Sleep(300);
4052
4053 thread1->Delete();
4054
456ae26d 4055 wxPuts(_T("\nDeleted a running thread."));
2f02cb89
VZ		 4056
4057 MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
4058
4059 thread2->Run();
4060
4061 wxThread::Sleep(300);
4062
4063 thread2->Pause();
4064
4065 thread2->Delete();
4066
456ae26d 4067 wxPuts(_T("\nDeleted a sleeping thread."));
2f02cb89 4068
4c460b34
VZ		 4069 MyJoinableThread thread3(20);
4070 thread3.Run();
2f02cb89 4071
4c460b34 4072 thread3.Delete();
2f02cb89 4073
456ae26d 4074 wxPuts(_T("\nDeleted a joinable thread."));
2f02cb89 4075
4c460b34
VZ		 4076 MyJoinableThread thread4(2);
4077 thread4.Run();
2f02cb89
VZ		 4078
4079 wxThread::Sleep(300);
4080
4c460b34 4081 thread4.Delete();
2f02cb89 4082
456ae26d 4083 wxPuts(_T("\nDeleted a joinable thread which already terminated."));
2f02cb89 4084
e9d2bb6f 4085 wxPuts(wxEmptyString);
2f02cb89
VZ		 4086}
4087
2f2f3e2a
VZ		 4088class MyWaitingThread : public wxThread
4089{
4090public:
c112e100 4091 MyWaitingThread( wxMutex *mutex, wxCondition *condition )
2f2f3e2a 4092 {
c112e100 4093 m_mutex = mutex;
2f2f3e2a
VZ		 4094 m_condition = condition;
4095
4096 Create();
4097 }
4098
4099 virtual ExitCode Entry()
4100 {
456ae26d 4101 wxPrintf(_T("Thread %lu has started running.\n"), GetId());
2f2f3e2a
VZ		 4102 fflush(stdout);
4103
c112e100 4104 gs_cond.Post();
2f2f3e2a 4105
456ae26d 4106 wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
2f2f3e2a
VZ		 4107 fflush(stdout);
4108
c112e100 4109 m_mutex->Lock();
2f2f3e2a 4110 m_condition->Wait();
c112e100 4111 m_mutex->Unlock();
2f2f3e2a 4112
456ae26d 4113 wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
2f2f3e2a
VZ		 4114 fflush(stdout);
4115
4116 return 0;
4117 }
4118
4119private:
c112e100 4120 wxMutex *m_mutex;
2f2f3e2a
VZ		 4121 wxCondition *m_condition;
4122};
4123
4124static void TestThreadConditions()
4125{
c112e100
VZ		 4126 wxMutex mutex;
4127 wxCondition condition(mutex);
2f2f3e2a 4128
8d5eff60
VZ		 4129 // otherwise its difficult to understand which log messages pertain to
4130 // which condition
456ae26d 4131 //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
c112e100 4132 // condition.GetId(), gs_cond.GetId());
8d5eff60 4133
2f2f3e2a 4134 // create and launch threads
60ce696e 4135 MyWaitingThread *threads[10];
2f2f3e2a
VZ		 4136
4137 size_t n;
4138 for ( n = 0; n < WXSIZEOF(threads); n++ )
4139 {
c112e100 4140 threads[n] = new MyWaitingThread( &mutex, &condition );
2f2f3e2a
VZ		 4141 }
4142
4143 for ( n = 0; n < WXSIZEOF(threads); n++ )
4144 {
4145 threads[n]->Run();
4146 }
4147
4148 // wait until all threads run
456ae26d 4149 wxPuts(_T("Main thread is waiting for the other threads to start"));
2f2f3e2a
VZ		 4150 fflush(stdout);
4151
4152 size_t nRunning = 0;
4153 while ( nRunning < WXSIZEOF(threads) )
4154 {
4155 gs_cond.Wait();
4156
2f2f3e2a 4157 nRunning++;
8d5eff60 4158
456ae26d 4159 wxPrintf(_T("Main thread: %u already running\n"), nRunning);
8d5eff60 4160 fflush(stdout);
2f2f3e2a
VZ		 4161 }
4162
456ae26d 4163 wxPuts(_T("Main thread: all threads started up."));
2f2f3e2a
VZ		 4164 fflush(stdout);
4165
8d5eff60
VZ		 4166 wxThread::Sleep(500);
4167
60ce696e 4168#if 1
8d5eff60 4169 // now wake one of them up
456ae26d 4170 wxPrintf(_T("Main thread: about to signal the condition.\n"));
2f2f3e2a
VZ		 4171 fflush(stdout);
4172 condition.Signal();
8d5eff60 4173#endif
2f2f3e2a 4174
60ce696e
VZ		 4175 wxThread::Sleep(200);
4176
8d5eff60 4177 // wake all the (remaining) threads up, so that they can exit
456ae26d 4178 wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
2f2f3e2a
VZ		 4179 fflush(stdout);
4180 condition.Broadcast();
4181
8d5eff60
VZ		 4182 // give them time to terminate (dirty!)
4183 wxThread::Sleep(500);
2f2f3e2a
VZ		 4184}
4185
c112e100
VZ		 4186#include "wx/utils.h"
4187
4188class MyExecThread : public wxThread
4189{
4190public:
4191 MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
4192 m_command(command)
4193 {
4194 Create();
4195 }
4196
4197 virtual ExitCode Entry()
4198 {
4199 return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
4200 }
4201
4202private:
4203 wxString m_command;
4204};
4205
4206static void TestThreadExec()
4207{
4208 wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
4209
4210 MyExecThread thread(_T("true"));
4211 thread.Run();
4212
4213 wxPrintf(_T("Main program exit code: %ld.\n"),
4214 wxExecute(_T("false"), wxEXEC_SYNC));
4215
4216 wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
4217}
4218
4219// semaphore tests
4220#include "wx/datetime.h"
4221
4222class MySemaphoreThread : public wxThread
4223{
4224public:
4225 MySemaphoreThread(int i, wxSemaphore *sem)
4226 : wxThread(wxTHREAD_JOINABLE),
4227 m_sem(sem),
4228 m_i(i)
4229 {
4230 Create();
4231 }
4232
4233 virtual ExitCode Entry()
4234 {
f06ef5f4
VZ		 4235 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
4236 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
c112e100
VZ		 4237
4238 m_sem->Wait();
4239
f06ef5f4
VZ		 4240 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
4241 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
c112e100
VZ		 4242
4243 Sleep(1000);
4244
f06ef5f4
VZ		 4245 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
4246 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
c112e100
VZ		 4247
4248 m_sem->Post();
4249
4250 return 0;
4251 }
4252
4253private:
4254 wxSemaphore *m_sem;
4255 int m_i;
4256};
4257
e9d2bb6f 4258WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
c112e100
VZ		 4259
4260static void TestSemaphore()
4261{
4262 wxPuts(_T("*** Testing wxSemaphore class. ***"));
4263
4264 static const int SEM_LIMIT = 3;
4265
4266 wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
4267 ArrayThreads threads;
4268
4269 for ( int i = 0; i < 3*SEM_LIMIT; i++ )
4270 {
4271 threads.Add(new MySemaphoreThread(i, &sem));
4272 threads.Last()->Run();
4273 }
4274
4275 for ( size_t n = 0; n < threads.GetCount(); n++ )
4276 {
4277 threads[n]->Wait();
4278 delete threads[n];
4279 }
4280}
4281
e87271f3
VZ		 4282#endif // TEST_THREADS
4283
e87271f3
VZ		 4284// ----------------------------------------------------------------------------
4285// entry point
4286// ----------------------------------------------------------------------------
4287
daa2c7d9
VZ		 4288#ifdef TEST_SNGLINST
4289 #include "wx/snglinst.h"
4290#endif // TEST_SNGLINST
4291
bbfa0322 4292int main(int argc, char **argv)
37667812 4293{
5ba95b79
WS		 4294#if wxUSE_UNICODE
4295 wxChar **wxArgv = new wxChar *[argc + 1];
4296
4297 {
4298 int n;
4299
4300 for (n = 0; n < argc; n++ )
4301 {
4302 wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
4303 wxArgv[n] = wxStrdup(warg);
4304 }
4305
4306 wxArgv[n] = NULL;
4307 }
4308#else // !wxUSE_UNICODE
4309 #define wxArgv argv
4310#endif // wxUSE_UNICODE/!wxUSE_UNICODE
4311
6f35ed60 4312 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
9cb47ea2 4313
58b24a56
VZ		 4314 wxInitializer initializer;
4315 if ( !initializer )
37667812 4316 {
be5a51fb 4317 fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
58b24a56
VZ		 4318
4319 return -1;
4320 }
4321
4322#ifdef TEST_SNGLINST
b5299791
VZ		 4323 wxSingleInstanceChecker checker;
4324 if ( checker.Create(_T(".wxconsole.lock")) )
58b24a56 4325 {
b5299791
VZ		 4326 if ( checker.IsAnotherRunning() )
4327 {
4328 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
58b24a56 4329
b5299791
VZ		 4330 return 1;
4331 }
37667812 4332
b5299791
VZ		 4333 // wait some time to give time to launch another instance
4334 wxPrintf(_T("Press \"Enter\" to continue..."));
4335 wxFgetc(stdin);
4336 }
4337 else // failed to create
4338 {
4339 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
4340 }
58b24a56
VZ		 4341#endif // TEST_SNGLINST
4342
d34bce84 4343#ifdef TEST_CMDLINE
31f6de22
VZ		 4344 TestCmdLineConvert();
4345
4346#if wxUSE_CMDLINE_PARSER
d34bce84
VZ		 4347 static const wxCmdLineEntryDesc cmdLineDesc[] =
4348 {
50c549b9 4349 { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
31a06b07 4350 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
50c549b9
VZ		 4351 { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
4352 { wxCMD_LINE_SWITCH, "q", "quiet", "be quiet" },
d34bce84 4353
50c549b9
VZ		 4354 { wxCMD_LINE_OPTION, "o", "output", "output file" },
4355 { wxCMD_LINE_OPTION, "i", "input", "input dir" },
4356 { wxCMD_LINE_OPTION, "s", "size", "output block size",
31a06b07 4357 wxCMD_LINE_VAL_NUMBER },
50c549b9 4358 { wxCMD_LINE_OPTION, "d", "date", "output file date",
31a06b07 4359 wxCMD_LINE_VAL_DATE },
b1859b1a
VZ		 4360 { wxCMD_LINE_OPTION, "f", "double", "output double",
4361 wxCMD_LINE_VAL_DOUBLE },
d34bce84 4362
50c549b9 4363 { wxCMD_LINE_PARAM, NULL, NULL, "input file",
d34bce84
VZ		 4364 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
4365
4366 { wxCMD_LINE_NONE }
4367 };
4368
5ba95b79 4369 wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
456ae26d
VZ		 4370
4371 parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
f6bcfd97
BP		 4372 wxCMD_LINE_VAL_STRING,
4373 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
4374
d34bce84
VZ		 4375 switch ( parser.Parse() )
4376 {
4377 case -1:
456ae26d 4378 wxLogMessage(_T("Help was given, terminating."));
d34bce84
VZ		 4379 break;
4380
4381 case 0:
4382 ShowCmdLine(parser);
4383 break;
4384
4385 default:
456ae26d 4386 wxLogMessage(_T("Syntax error detected, aborting."));
d34bce84
VZ		 4387 break;
4388 }
31f6de22
VZ		 4389#endif // wxUSE_CMDLINE_PARSER
4390
d34bce84
VZ		 4391#endif // TEST_CMDLINE
4392
1944c6bd 4393#ifdef TEST_DIR
e9d2bb6f 4394 #if TEST_ALL
99a5af7f 4395 TestDirExists();
2f0c19d0 4396 TestDirEnum();
e9d2bb6f 4397 #endif
2f0c19d0 4398 TestDirTraverse();
1944c6bd
VZ		 4399#endif // TEST_DIR
4400
93ed8ff7 4401#ifdef TEST_DYNLIB
f6bcfd97 4402 TestDllLoad();
297ebe6b 4403 TestDllListLoaded();
93ed8ff7 4404#endif // TEST_DYNLIB
f6bcfd97 4405
8fd0d89b
VZ		 4406#ifdef TEST_ENVIRON
4407 TestEnvironment();
4408#endif // TEST_ENVIRON
4409
d93c719a
VZ		 4410#ifdef TEST_EXECUTE
4411 TestExecute();
4412#endif // TEST_EXECUTE
4413
ee6e1b1d
VZ		 4414#ifdef TEST_FILECONF
4415 TestFileConfRead();
4416#endif // TEST_FILECONF
4417
ec37df57
VZ		 4418#ifdef TEST_LOCALE
4419 TestDefaultLang();
4420#endif // TEST_LOCALE
4421
378b05f7 4422#ifdef TEST_LOG
cab8f76e
VZ		 4423 wxPuts(_T("*** Testing wxLog ***"));
4424
378b05f7
VZ		 4425 wxString s;
4426 for ( size_t n = 0; n < 8000; n++ )
4427 {
456ae26d 4428 s << (wxChar)(_T('A') + (n % 26));
378b05f7
VZ		 4429 }
4430
cab8f76e
VZ		 4431 wxLogWarning(_T("The length of the string is %lu"),
4432 (unsigned long)s.length());
4433
378b05f7 4434 wxString msg;
456ae26d 4435 msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
378b05f7
VZ		 4436
4437 // this one shouldn't be truncated
456ae26d 4438 wxPrintf(msg);
378b05f7
VZ		 4439
4440 // but this one will because log functions use fixed size buffer
b568d04f
VZ		 4441 // (note that it doesn't need '\n' at the end neither - will be added
4442 // by wxLog anyhow)
456ae26d 4443 wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
378b05f7
VZ		 4444#endif // TEST_LOG
4445
f6bcfd97 4446#ifdef TEST_FILE
e9d2bb6f
DS		 4447 TestFileRead();
4448 TestTextFileRead();
4449 TestFileCopy();
59062ec1 4450 TestTempFile();
f6bcfd97
BP		 4451#endif // TEST_FILE
4452
844f90fb 4453#ifdef TEST_FILENAME
e9d2bb6f
DS		 4454 TestFileNameTemp();
4455 TestFileNameCwd();
4456 TestFileNameDirManip();
4457 TestFileNameComparison();
4458 TestFileNameOperations();
844f90fb
VZ		 4459#endif // TEST_FILENAME
4460
d56e2b97
VZ		 4461#ifdef TEST_FILETIME
4462 TestFileGetTimes();
e9d2bb6f 4463 #if 0
d56e2b97 4464 TestFileSetTimes();
e9d2bb6f 4465 #endif
d56e2b97
VZ		 4466#endif // TEST_FILETIME
4467
07a56e45
VZ		 4468#ifdef TEST_FTP
4469 wxLog::AddTraceMask(FTP_TRACE_MASK);
4470 if ( TestFtpConnect() )
4471 {
e9d2bb6f 4472 #if TEST_ALL
07a56e45
VZ		 4473 TestFtpList();
4474 TestFtpDownload();
4475 TestFtpMisc();
daa2c7d9 4476 TestFtpFileSize();
07a56e45 4477 TestFtpUpload();
af33b199 4478 #endif // TEST_ALL
daa2c7d9 4479
e9d2bb6f 4480 #if TEST_INTERACTIVE
daa2c7d9 4481 TestFtpInteractive();
e9d2bb6f 4482 #endif
07a56e45
VZ		 4483 }
4484 //else: connecting to the FTP server failed
4485
e9d2bb6f 4486 #if 0
07a56e45 4487 TestFtpWuFtpd();
e9d2bb6f 4488 #endif
07a56e45
VZ		 4489#endif // TEST_FTP
4490
696e1ea0 4491#ifdef TEST_MIME
b61af837
VZ		 4492 //wxLog::AddTraceMask(_T("mime"));
4493 TestMimeEnum();
c19c2f6e 4494#if 0
b61af837 4495 TestMimeOverride();
c19c2f6e
VZ		 4496 TestMimeAssociate();
4497#endif
f06ef5f4 4498 TestMimeFilename();
696e1ea0
VZ		 4499#endif // TEST_MIME
4500
89e60357 4501#ifdef TEST_INFO_FUNCTIONS
8bb6b2c0
VZ		 4502 TestOsInfo();
4503 TestPlatformInfo();
4504 TestUserInfo();
19f45995 4505
8bb6b2c0
VZ		 4506 #if TEST_INTERACTIVE
4507 TestDiskInfo();
e9d2bb6f 4508 #endif
89e60357
VZ		 4509#endif // TEST_INFO_FUNCTIONS
4510
39189b9d
VZ		 4511#ifdef TEST_PATHLIST
4512 TestPathList();
4513#endif // TEST_PATHLIST
4514
7aeebdcd
VZ		 4515#ifdef TEST_PRINTF
4516 TestPrintf();
4517#endif // TEST_PRINTF
4518
7ba4fbeb 4519#ifdef TEST_REGCONF
e9d2bb6f
DS		 4520 #if 0
4521 TestRegConfWrite();
4522 #endif
0aa29b6b 4523 TestRegConfRead();
7ba4fbeb
VZ		 4524#endif // TEST_REGCONF
4525
bc10103e
VS		 4526#if defined TEST_REGEX && TEST_INTERACTIVE
4527 TestRegExInteractive();
4528#endif // defined TEST_REGEX && TEST_INTERACTIVE
07a56e45 4529
6dfec4b8 4530#ifdef TEST_REGISTRY
daa2c7d9 4531 TestRegistryRead();
6ba63600 4532 TestRegistryAssociation();
6dfec4b8
VZ		 4533#endif // TEST_REGISTRY
4534
2c8e4738 4535#ifdef TEST_SOCKETS
daa2c7d9
VZ		 4536 TestSocketServer();
4537 TestSocketClient();
2c8e4738
VZ		 4538#endif // TEST_SOCKETS
4539
83141d3a 4540#ifdef TEST_STREAMS
e9d2bb6f 4541 #if TEST_ALL
99a5af7f 4542 TestFileStream();
e9d2bb6f 4543 #endif
99a5af7f 4544 TestMemoryStream();
83141d3a
VZ		 4545#endif // TEST_STREAMS
4546
39937656
VZ		 4547#ifdef TEST_TEXTSTREAM
4548 TestTextInputStream();
4549#endif // TEST_TEXTSTREAM
4550
8d5eff60
VZ		 4551#ifdef TEST_THREADS
4552 int nCPUs = wxThread::GetCPUCount();
456ae26d 4553 wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
8d5eff60
VZ		 4554 if ( nCPUs != -1 )
4555 wxThread::SetConcurrency(nCPUs);
4556
5bc1deeb
VZ		 4557 TestJoinableThreads();
4558
e9d2bb6f 4559 #if TEST_ALL
8d5eff60 4560 TestJoinableThreads();
5bc1deeb 4561 TestDetachedThreads();
8d5eff60
VZ		 4562 TestThreadSuspend();
4563 TestThreadDelete();
c112e100
VZ		 4564 TestThreadConditions();
4565 TestThreadExec();
7aeebdcd 4566 TestSemaphore();
e9d2bb6f 4567 #endif
8d5eff60
VZ		 4568#endif // TEST_THREADS
4569
d31b7b68
VZ		 4570#ifdef TEST_TIMER
4571 TestStopWatch();
549b95b3 4572 TestTimer();
d31b7b68
VZ		 4573#endif // TEST_TIMER
4574
4575#ifdef TEST_DATETIME
e9d2bb6f 4576 #if TEST_ALL
9d9b7755
VZ		 4577 TestTimeStatic();
4578 TestTimeRange();
4579 TestTimeZones();
9d9b7755 4580 TestTimeDST();
f6bcfd97 4581 TestTimeHolidays();
daa2c7d9 4582 TestTimeSpanFormat();
3ca6a5f0 4583 TestTimeMS();
f6bcfd97
BP		 4584
4585 TestTimeZoneBug();
e9d2bb6f 4586 #endif
2b5f62a0 4587
e9d2bb6f 4588 #if TEST_INTERACTIVE
b92fd37c 4589 TestDateTimeInteractive();
e9d2bb6f 4590 #endif
d31b7b68 4591#endif // TEST_DATETIME
b76b015e 4592
df5168c4
MB		 4593#ifdef TEST_SCOPEGUARD
4594 TestScopeGuard();
4595#endif
4596
eaff0f0d 4597#ifdef TEST_STACKWALKER
60c474a0 4598#if wxUSE_STACKWALKER
eaff0f0d 4599 TestStackWalk(argv[0]);
60c474a0 4600#endif
eaff0f0d
VZ		 4601#endif // TEST_STACKWALKER
4602
af33b199
VZ		 4603#ifdef TEST_STDPATHS
4604 TestStandardPaths();
4605#endif
4606
551fe3a6 4607#ifdef TEST_USLEEP
456ae26d 4608 wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
551fe3a6
VZ		 4609 wxUsleep(3000);
4610#endif // TEST_USLEEP
4611
f6bcfd97 4612#ifdef TEST_VCARD
f6bcfd97
BP		 4613 TestVCardRead();
4614 TestVCardWrite();
4615#endif // TEST_VCARD
4616
0e2c5534
VZ		 4617#ifdef TEST_VOLUME
4618 TestFSVolume();
4619#endif // TEST_VOLUME
4620
f6bcfd97
BP		 4621#ifdef TEST_WCHAR
4622 TestUtf8();
ac511156 4623 TestEncodingConverter();
f6bcfd97
BP		 4624#endif // TEST_WCHAR
4625
4626#ifdef TEST_ZIP
daa2c7d9 4627 TestZipStreamRead();
2ca8b884 4628 TestZipFileSystem();
f6bcfd97
BP		 4629#endif // TEST_ZIP
4630
5ba95b79
WS		 4631#if wxUSE_UNICODE
4632 {
4633 for ( int n = 0; n < argc; n++ )
4634 free(wxArgv[n]);
4635
4636 delete [] wxArgv;
4637 }
4638#endif // wxUSE_UNICODE
4639
e9d2bb6f
DS		 4640 wxUnusedVar(argc);
4641 wxUnusedVar(argv);
37667812
VZ		 4642 return 0;
4643}
wxWidgets (Impactor)