remove MSVC solution files from svn
[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.
eb835127 104#define TEST_ALL 1
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
eb835127 118 #define TEST_FTP
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
eb835127 1686#if defined TEST_REGEX && TEST_INTERACTIVE
07a56e45 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
b92fd37c 2475#ifdef FTP_ANONYMOUS
349c045a 2476 static const wxChar *hostname = _T("ftp.wxwidgets.org");
b92fd37c 2477
456ae26d 2478 wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
b92fd37c 2479#else // !FTP_ANONYMOUS
456ae26d 2480 static const wxChar *hostname = "localhost";
b92fd37c 2481
456ae26d
VZ
2482 wxChar user[256];
2483 wxFgets(user, WXSIZEOF(user), stdin);
2484 user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
d6accb8c 2485 ftp->SetUser(user);
b92fd37c 2486
456ae26d
VZ
2487 wxChar password[256];
2488 wxPrintf(_T("Password for %s: "), password);
2489 wxFgets(password, WXSIZEOF(password), stdin);
2490 password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
d6accb8c 2491 ftp->SetPassword(password);
b92fd37c 2492
456ae26d 2493 wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
b92fd37c
VZ
2494#endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2495
d6accb8c 2496 if ( !ftp->Connect(hostname) )
b92fd37c 2497 {
456ae26d 2498 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
b92fd37c 2499
cab8f76e 2500 return false;
b92fd37c
VZ
2501 }
2502 else
2503 {
456ae26d 2504 wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
d6accb8c
FM
2505 hostname, ftp->Pwd().c_str());
2506 ftp->Close();
b92fd37c
VZ
2507 }
2508
cab8f76e 2509 return true;
b92fd37c 2510}
b1229561 2511
b92fd37c
VZ
2512static void TestFtpList()
2513{
456ae26d 2514 wxPuts(_T("*** Testing wxFTP file listing ***\n"));
8e907a13 2515
b92fd37c 2516 // test CWD
d6accb8c 2517 if ( !ftp->ChDir(directory) )
b92fd37c 2518 {
456ae26d 2519 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
b92fd37c 2520 }
2e907fab 2521
d6accb8c 2522 wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
2e907fab 2523
b92fd37c
VZ
2524 // test NLIST and LIST
2525 wxArrayString files;
d6accb8c 2526 if ( !ftp->GetFilesList(files) )
8e907a13 2527 {
456ae26d 2528 wxPuts(_T("ERROR: failed to get NLIST of files"));
8e907a13
VZ
2529 }
2530 else
2531 {
d6accb8c 2532 wxPrintf(_T("Brief list of files under '%s':\n"), ftp->Pwd().c_str());
b92fd37c
VZ
2533 size_t count = files.GetCount();
2534 for ( size_t n = 0; n < count; n++ )
8e907a13 2535 {
456ae26d 2536 wxPrintf(_T("\t%s\n"), files[n].c_str());
8e907a13 2537 }
456ae26d 2538 wxPuts(_T("End of the file list"));
b92fd37c 2539 }
8e907a13 2540
d6accb8c 2541 if ( !ftp->GetDirList(files) )
b92fd37c 2542 {
456ae26d 2543 wxPuts(_T("ERROR: failed to get LIST of files"));
b92fd37c
VZ
2544 }
2545 else
2546 {
d6accb8c 2547 wxPrintf(_T("Detailed list of files under '%s':\n"), ftp->Pwd().c_str());
b92fd37c
VZ
2548 size_t count = files.GetCount();
2549 for ( size_t n = 0; n < count; n++ )
8e907a13 2550 {
456ae26d 2551 wxPrintf(_T("\t%s\n"), files[n].c_str());
2e907fab 2552 }
456ae26d 2553 wxPuts(_T("End of the file list"));
b92fd37c
VZ
2554 }
2555
d6accb8c 2556 if ( !ftp->ChDir(_T("..")) )
b92fd37c 2557 {
456ae26d 2558 wxPuts(_T("ERROR: failed to cd to .."));
b92fd37c 2559 }
2e907fab 2560
d6accb8c 2561 wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
b92fd37c
VZ
2562}
2563
2564static void TestFtpDownload()
2565{
456ae26d 2566 wxPuts(_T("*** Testing wxFTP download ***\n"));
b92fd37c
VZ
2567
2568 // test RETR
d6accb8c 2569 wxInputStream *in = ftp->GetInputStream(filename);
b92fd37c
VZ
2570 if ( !in )
2571 {
456ae26d 2572 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
b92fd37c
VZ
2573 }
2574 else
2575 {
4c51b688 2576 size_t size = in->GetSize();
456ae26d 2577 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
b92fd37c
VZ
2578 fflush(stdout);
2579
456ae26d 2580 wxChar *data = new wxChar[size];
b92fd37c 2581 if ( !in->Read(data, size) )
2e907fab 2582 {
456ae26d 2583 wxPuts(_T("ERROR: read error"));
2e907fab
VZ
2584 }
2585 else
2586 {
456ae26d 2587 wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
8e907a13
VZ
2588 }
2589
b92fd37c
VZ
2590 delete [] data;
2591 delete in;
2592 }
2593}
8e907a13 2594
b92fd37c
VZ
2595static void TestFtpFileSize()
2596{
456ae26d 2597 wxPuts(_T("*** Testing FTP SIZE command ***"));
b92fd37c 2598
d6accb8c 2599 if ( !ftp->ChDir(directory) )
b92fd37c 2600 {
456ae26d 2601 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
b92fd37c
VZ
2602 }
2603
d6accb8c 2604 wxPrintf(_T("Current directory is '%s'\n"), ftp->Pwd().c_str());
b92fd37c 2605
d6accb8c 2606 if ( ftp->FileExists(filename) )
b92fd37c 2607 {
d6accb8c 2608 int size = ftp->GetFileSize(filename);
b92fd37c 2609 if ( size == -1 )
456ae26d 2610 wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
8e907a13 2611 else
456ae26d 2612 wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
b92fd37c
VZ
2613 }
2614 else
2615 {
456ae26d 2616 wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
b92fd37c
VZ
2617 }
2618}
2619
2620static void TestFtpMisc()
2621{
456ae26d 2622 wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
b92fd37c 2623
d6accb8c 2624 if ( ftp->SendCommand(_T("STAT")) != '2' )
b92fd37c 2625 {
456ae26d 2626 wxPuts(_T("ERROR: STAT failed"));
b92fd37c
VZ
2627 }
2628 else
2629 {
d6accb8c 2630 wxPrintf(_T("STAT returned:\n\n%s\n"), ftp->GetLastResult().c_str());
b92fd37c
VZ
2631 }
2632
d6accb8c 2633 if ( ftp->SendCommand(_T("HELP SITE")) != '2' )
b92fd37c 2634 {
456ae26d 2635 wxPuts(_T("ERROR: HELP SITE failed"));
b92fd37c
VZ
2636 }
2637 else
2638 {
456ae26d 2639 wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
d6accb8c 2640 ftp->GetLastResult().c_str());
b92fd37c
VZ
2641 }
2642}
2643
eb835127
FM
2644#if TEST_INTERACTIVE
2645
b92fd37c
VZ
2646static void TestFtpInteractive()
2647{
456ae26d 2648 wxPuts(_T("\n*** Interactive wxFTP test ***"));
b92fd37c 2649
456ae26d 2650 wxChar buf[128];
b92fd37c
VZ
2651
2652 for ( ;; )
2653 {
456ae26d
VZ
2654 wxPrintf(_T("Enter FTP command: "));
2655 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
b92fd37c
VZ
2656 break;
2657
2658 // kill the last '\n'
456ae26d 2659 buf[wxStrlen(buf) - 1] = 0;
b92fd37c
VZ
2660
2661 // special handling of LIST and NLST as they require data connection
2662 wxString start(buf, 4);
2663 start.MakeUpper();
f2cb8a17 2664 if ( start == _T("LIST") || start == _T("NLST") )
8e907a13 2665 {
b92fd37c 2666 wxString wildcard;
456ae26d 2667 if ( wxStrlen(buf) > 4 )
b92fd37c 2668 wildcard = buf + 5;
8e907a13 2669
b92fd37c 2670 wxArrayString files;
d6accb8c 2671 if ( !ftp->GetList(files, wildcard, start == _T("LIST")) )
8e907a13 2672 {
456ae26d 2673 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
8e907a13
VZ
2674 }
2675 else
2676 {
456ae26d 2677 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
d6accb8c 2678 start.c_str(), wildcard.c_str(), ftp->Pwd().c_str());
b92fd37c
VZ
2679 size_t count = files.GetCount();
2680 for ( size_t n = 0; n < count; n++ )
2681 {
456ae26d 2682 wxPrintf(_T("\t%s\n"), files[n].c_str());
b92fd37c 2683 }
456ae26d 2684 wxPuts(_T("--- End of the file list"));
8e907a13 2685 }
2e907fab 2686 }
b92fd37c 2687 else // !list
2e907fab 2688 {
d6accb8c 2689 wxChar ch = ftp->SendCommand(buf);
456ae26d 2690 wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
b92fd37c
VZ
2691 if ( ch )
2692 {
456ae26d 2693 wxPrintf(_T(" (return code %c)"), ch);
b92fd37c 2694 }
2e907fab 2695
d6accb8c 2696 wxPrintf(_T(", server reply:\n%s\n\n"), ftp->GetLastResult().c_str());
2e907fab 2697 }
2c8e4738 2698 }
b92fd37c 2699
456ae26d 2700 wxPuts(_T("\n*** done ***"));
2c8e4738
VZ
2701}
2702
eb835127
FM
2703#endif // TEST_INTERACTIVE
2704
b92fd37c 2705static void TestFtpUpload()
f6bcfd97 2706{
456ae26d 2707 wxPuts(_T("*** Testing wxFTP uploading ***\n"));
f6bcfd97 2708
b92fd37c 2709 // upload a file
456ae26d
VZ
2710 static const wxChar *file1 = _T("test1");
2711 static const wxChar *file2 = _T("test2");
d6accb8c 2712 wxOutputStream *out = ftp->GetOutputStream(file1);
b92fd37c
VZ
2713 if ( out )
2714 {
456ae26d 2715 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
b92fd37c
VZ
2716 out->Write("First hello", 11);
2717 delete out;
2718 }
f6bcfd97 2719
b92fd37c 2720 // send a command to check the remote file
d6accb8c 2721 if ( ftp->SendCommand(wxString(_T("STAT ")) + file1) != '2' )
f6bcfd97 2722 {
456ae26d 2723 wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
f6bcfd97
BP
2724 }
2725 else
2726 {
456ae26d 2727 wxPrintf(_T("STAT %s returned:\n\n%s\n"),
d6accb8c 2728 file1, ftp->GetLastResult().c_str());
b92fd37c 2729 }
2e907fab 2730
d6accb8c 2731 out = ftp->GetOutputStream(file2);
b92fd37c
VZ
2732 if ( out )
2733 {
456ae26d 2734 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
b92fd37c
VZ
2735 out->Write("Second hello", 12);
2736 delete out;
f6bcfd97
BP
2737 }
2738}
2739
2e907fab 2740#endif // TEST_FTP
2c8e4738 2741
eaff0f0d
VZ
2742// ----------------------------------------------------------------------------
2743// stack backtrace
2744// ----------------------------------------------------------------------------
2745
2746#ifdef TEST_STACKWALKER
2747
74e2116a
MB
2748#if wxUSE_STACKWALKER
2749
eaff0f0d
VZ
2750#include "wx/stackwalk.h"
2751
2752class StackDump : public wxStackWalker
2753{
2754public:
2755 StackDump(const char *argv0)
2756 : wxStackWalker(argv0)
2757 {
2758 }
2759
eb835127 2760 virtual void Walk(size_t skip = 1, size_t maxdepth = wxSTACKWALKER_MAX_DEPTH)
eaff0f0d
VZ
2761 {
2762 wxPuts(_T("Stack dump:"));
2763
eb835127 2764 wxStackWalker::Walk(skip, maxdepth);
eaff0f0d
VZ
2765 }
2766
2767protected:
2768 virtual void OnStackFrame(const wxStackFrame& frame)
2769 {
bf3bf677 2770 printf("[%2d] ", (int) frame.GetLevel());
eaff0f0d
VZ
2771
2772 wxString name = frame.GetName();
2773 if ( !name.empty() )
2774 {
bf3bf677 2775 printf("%-20.40s", (const char*)name.mb_str());
eaff0f0d
VZ
2776 }
2777 else
2778 {
2779 printf("0x%08lx", (unsigned long)frame.GetAddress());
2780 }
2781
2782 if ( frame.HasSourceLocation() )
2783 {
2784 printf("\t%s:%d",
bf3bf677
VZ
2785 (const char*)frame.GetFileName().mb_str(),
2786 (int)frame.GetLine());
eaff0f0d
VZ
2787 }
2788
2789 puts("");
2790
2791 wxString type, val;
2792 for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
2793 {
3e231024
FM
2794 printf("\t%s %s = %s\n", (const char*)type.mb_str(),
2795 (const char*)name.mb_str(),
bf3bf677 2796 (const char*)val.mb_str());
eaff0f0d
VZ
2797 }
2798 }
2799};
2800
2801static void TestStackWalk(const char *argv0)
2802{
2803 wxPuts(_T("*** Testing wxStackWalker ***\n"));
2804
2805 StackDump dump(argv0);
2806 dump.Walk();
2807}
2808
74e2116a
MB
2809#endif // wxUSE_STACKWALKER
2810
eaff0f0d
VZ
2811#endif // TEST_STACKWALKER
2812
af33b199
VZ
2813// ----------------------------------------------------------------------------
2814// standard paths
2815// ----------------------------------------------------------------------------
2816
2817#ifdef TEST_STDPATHS
2818
2819#include "wx/stdpaths.h"
6f207e66 2820#include "wx/wxchar.h" // wxPrintf
af33b199
VZ
2821
2822static void TestStandardPaths()
2823{
2824 wxPuts(_T("*** Testing wxStandardPaths ***\n"));
2825
2826 wxTheApp->SetAppName(_T("console"));
2827
5ba95b79 2828 wxStandardPathsBase& stdp = wxStandardPaths::Get();
af33b199
VZ
2829 wxPrintf(_T("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
2830 wxPrintf(_T("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
2831 wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
2832 wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
2833 wxPrintf(_T("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
2834 wxPrintf(_T("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
17af82fb 2835 wxPrintf(_T("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
ac7ad70d 2836 wxPrintf(_T("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
af33b199 2837 wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
3af9f2de
VZ
2838 wxPrintf(_T("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
2839 wxPrintf(_T("Localized res. dir:\t%s\n"),
2840 stdp.GetLocalizedResourcesDir(_T("fr")).c_str());
2841 wxPrintf(_T("Message catalogs dir:\t%s\n"),
2842 stdp.GetLocalizedResourcesDir
2843 (
2844 _T("fr"),
2845 wxStandardPaths::ResourceCat_Messages
2846 ).c_str());
af33b199
VZ
2847}
2848
2849#endif // TEST_STDPATHS
2850
83141d3a
VZ
2851// ----------------------------------------------------------------------------
2852// streams
2853// ----------------------------------------------------------------------------
2854
2855#ifdef TEST_STREAMS
2856
e84010cf
GD
2857#include "wx/wfstream.h"
2858#include "wx/mstream.h"
83141d3a 2859
24f25c8a
VZ
2860static void TestFileStream()
2861{
456ae26d 2862 wxPuts(_T("*** Testing wxFileInputStream ***"));
24f25c8a 2863
e9d2bb6f 2864 static const wxString filename = _T("testdata.fs");
24f25c8a
VZ
2865 {
2866 wxFileOutputStream fsOut(filename);
2867 fsOut.Write("foo", 3);
2868 }
2869
24f25c8a 2870 {
5df663af
VZ
2871 wxFileInputStream fsIn(filename);
2872 wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
eb835127
FM
2873 int c;
2874 while ( (c=fsIn.GetC()) != wxEOF )
5df663af 2875 {
eb835127 2876 wxPutchar(c);
5df663af 2877 }
24f25c8a
VZ
2878 }
2879
2880 if ( !wxRemoveFile(filename) )
2881 {
e9d2bb6f 2882 wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
24f25c8a
VZ
2883 }
2884
456ae26d 2885 wxPuts(_T("\n*** wxFileInputStream test done ***"));
24f25c8a
VZ
2886}
2887
83141d3a
VZ
2888static void TestMemoryStream()
2889{
99a5af7f
VZ
2890 wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
2891
2892 wxMemoryOutputStream memOutStream;
2893 wxPrintf(_T("Initially out stream offset: %lu\n"),
2894 (unsigned long)memOutStream.TellO());
2895
2896 for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
2897 {
2898 memOutStream.PutC(*p);
2899 }
2900
2901 wxPrintf(_T("Final out stream offset: %lu\n"),
2902 (unsigned long)memOutStream.TellO());
2903
2904 wxPuts(_T("*** Testing wxMemoryInputStream ***"));
83141d3a
VZ
2905
2906 wxChar buf[1024];
99a5af7f 2907 size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
83141d3a 2908
99a5af7f
VZ
2909 wxMemoryInputStream memInpStream(buf, len);
2910 wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
eb835127
FM
2911 int c;
2912 while ( (c=memInpStream.GetC()) != wxEOF )
83141d3a 2913 {
eb835127 2914 wxPutchar(c);
83141d3a
VZ
2915 }
2916
456ae26d 2917 wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
83141d3a
VZ
2918}
2919
2920#endif // TEST_STREAMS
2921
d31b7b68
VZ
2922// ----------------------------------------------------------------------------
2923// timers
2924// ----------------------------------------------------------------------------
2925
2926#ifdef TEST_TIMER
2927
5ba95b79 2928#include "wx/stopwatch.h"
e84010cf 2929#include "wx/utils.h"
d31b7b68
VZ
2930
2931static void TestStopWatch()
2932{
456ae26d 2933 wxPuts(_T("*** Testing wxStopWatch ***\n"));
d31b7b68
VZ
2934
2935 wxStopWatch sw;
677eff07 2936 sw.Pause();
456ae26d 2937 wxPrintf(_T("Initially paused, after 2 seconds time is..."));
677eff07
VZ
2938 fflush(stdout);
2939 wxSleep(2);
456ae26d 2940 wxPrintf(_T("\t%ldms\n"), sw.Time());
677eff07 2941
456ae26d 2942 wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
677eff07
VZ
2943 fflush(stdout);
2944 sw.Resume();
d31b7b68 2945 wxSleep(3);
456ae26d 2946 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
d31b7b68
VZ
2947
2948 sw.Pause();
456ae26d 2949 wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
677eff07 2950 fflush(stdout);
d31b7b68 2951 wxSleep(2);
456ae26d 2952 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
d31b7b68
VZ
2953
2954 sw.Resume();
456ae26d 2955 wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
677eff07
VZ
2956 fflush(stdout);
2957 wxSleep(2);
456ae26d 2958 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
87798c00
VZ
2959
2960 wxStopWatch sw2;
456ae26d 2961 wxPuts(_T("\nChecking for 'backwards clock' bug..."));
87798c00
VZ
2962 for ( size_t n = 0; n < 70; n++ )
2963 {
2964 sw2.Start();
89e6463c
GRG
2965
2966 for ( size_t m = 0; m < 100000; m++ )
87798c00 2967 {
89e6463c
GRG
2968 if ( sw.Time() < 0 || sw2.Time() < 0 )
2969 {
456ae26d 2970 wxPuts(_T("\ntime is negative - ERROR!"));
89e6463c 2971 }
87798c00
VZ
2972 }
2973
e9d2bb6f 2974 wxPutchar('.');
677eff07 2975 fflush(stdout);
87798c00
VZ
2976 }
2977
456ae26d 2978 wxPuts(_T(", ok."));
d31b7b68
VZ
2979}
2980
549b95b3
VZ
2981#include "wx/timer.h"
2982#include "wx/evtloop.h"
2983
2984void TestTimer()
2985{
2986 wxPuts(_T("*** Testing wxTimer ***\n"));
2987
2988 class MyTimer : public wxTimer
2989 {
2990 public:
2991 MyTimer() : wxTimer() { m_num = 0; }
2992
2993 virtual void Notify()
2994 {
2995 wxPrintf(_T("%d"), m_num++);
74e10fcc 2996 fflush(stdout);
549b95b3
VZ
2997
2998 if ( m_num == 10 )
2999 {
3000 wxPrintf(_T("... exiting the event loop"));
3001 Stop();
3002
3003 wxEventLoop::GetActive()->Exit(0);
3004 wxPuts(_T(", ok."));
3005 }
3006
3007 fflush(stdout);
3008 }
3009
3010 private:
3011 int m_num;
3012 };
3013
3014 wxEventLoop loop;
3015
74e10fcc
VZ
3016 wxTimer timer1;
3017 timer1.Start(100, true /* one shot */);
3018 timer1.Stop();
3019 timer1.Start(100, true /* one shot */);
3020
549b95b3
VZ
3021 MyTimer timer;
3022 timer.Start(500);
3023
3024 loop.Run();
3025}
3026
d31b7b68
VZ
3027#endif // TEST_TIMER
3028
f6bcfd97
BP
3029// ----------------------------------------------------------------------------
3030// vCard support
3031// ----------------------------------------------------------------------------
3032
3033#ifdef TEST_VCARD
3034
e84010cf 3035#include "wx/vcard.h"
f6bcfd97
BP
3036
3037static void DumpVObject(size_t level, const wxVCardObject& vcard)
3038{
3039 void *cookie;
3040 wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3041 while ( vcObj )
3042 {
456ae26d 3043 wxPrintf(_T("%s%s"),
f6bcfd97
BP
3044 wxString(_T('\t'), level).c_str(),
3045 vcObj->GetName().c_str());
3046
3047 wxString value;
3048 switch ( vcObj->GetType() )
3049 {
3050 case wxVCardObject::String:
3051 case wxVCardObject::UString:
3052 {
3053 wxString val;
3054 vcObj->GetValue(&val);
3055 value << _T('"') << val << _T('"');
3056 }
3057 break;
3058
3059 case wxVCardObject::Int:
3060 {
3061 unsigned int i;
3062 vcObj->GetValue(&i);
3063 value.Printf(_T("%u"), i);
3064 }
3065 break;
3066
3067 case wxVCardObject::Long:
3068 {
3069 unsigned long l;
3070 vcObj->GetValue(&l);
3071 value.Printf(_T("%lu"), l);
3072 }
3073 break;
3074
3075 case wxVCardObject::None:
3076 break;
3077
3078 case wxVCardObject::Object:
3079 value = _T("<node>");
3080 break;
3081
3082 default:
3083 value = _T("<unknown value type>");
3084 }
3085
3086 if ( !!value )
456ae26d 3087 wxPrintf(_T(" = %s"), value.c_str());
e9d2bb6f 3088 wxPutchar('\n');
f6bcfd97
BP
3089
3090 DumpVObject(level + 1, *vcObj);
3091
3092 delete vcObj;
3093 vcObj = vcard.GetNextProp(&cookie);
3094 }
3095}
3096
3097static void DumpVCardAddresses(const wxVCard& vcard)
3098{
456ae26d 3099 wxPuts(_T("\nShowing all addresses from vCard:\n"));
f6bcfd97
BP
3100
3101 size_t nAdr = 0;
3102 void *cookie;
3103 wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3104 while ( addr )
3105 {
3106 wxString flagsStr;
3107 int flags = addr->GetFlags();
3108 if ( flags & wxVCardAddress::Domestic )
3109 {
3110 flagsStr << _T("domestic ");
3111 }
3112 if ( flags & wxVCardAddress::Intl )
3113 {
3114 flagsStr << _T("international ");
3115 }
3116 if ( flags & wxVCardAddress::Postal )
3117 {
3118 flagsStr << _T("postal ");
3119 }
3120 if ( flags & wxVCardAddress::Parcel )
3121 {
3122 flagsStr << _T("parcel ");
3123 }
3124 if ( flags & wxVCardAddress::Home )
3125 {
3126 flagsStr << _T("home ");
3127 }
3128 if ( flags & wxVCardAddress::Work )
3129 {
3130 flagsStr << _T("work ");
3131 }
3132
456ae26d 3133 wxPrintf(_T("Address %u:\n")
f6bcfd97
BP
3134 "\tflags = %s\n"
3135 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3136 ++nAdr,
3137 flagsStr.c_str(),
3138 addr->GetPostOffice().c_str(),
3139 addr->GetExtAddress().c_str(),
3140 addr->GetStreet().c_str(),
3141 addr->GetLocality().c_str(),
3142 addr->GetRegion().c_str(),
3143 addr->GetPostalCode().c_str(),
3144 addr->GetCountry().c_str()
3145 );
3146
3147 delete addr;
3148 addr = vcard.GetNextAddress(&cookie);
3149 }
3150}
3151
3152static void DumpVCardPhoneNumbers(const wxVCard& vcard)
3153{
456ae26d 3154 wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
f6bcfd97
BP
3155
3156 size_t nPhone = 0;
3157 void *cookie;
3158 wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
3159 while ( phone )
3160 {
3161 wxString flagsStr;
3162 int flags = phone->GetFlags();
3163 if ( flags & wxVCardPhoneNumber::Voice )
3164 {
3165 flagsStr << _T("voice ");
3166 }
3167 if ( flags & wxVCardPhoneNumber::Fax )
3168 {
3169 flagsStr << _T("fax ");
3170 }
3171 if ( flags & wxVCardPhoneNumber::Cellular )
3172 {
3173 flagsStr << _T("cellular ");
3174 }
3175 if ( flags & wxVCardPhoneNumber::Modem )
3176 {
3177 flagsStr << _T("modem ");
3178 }
3179 if ( flags & wxVCardPhoneNumber::Home )
3180 {
3181 flagsStr << _T("home ");
3182 }
3183 if ( flags & wxVCardPhoneNumber::Work )
3184 {
3185 flagsStr << _T("work ");
3186 }
3187
456ae26d 3188 wxPrintf(_T("Phone number %u:\n")
f6bcfd97
BP
3189 "\tflags = %s\n"
3190 "\tvalue = %s\n",
3191 ++nPhone,
3192 flagsStr.c_str(),
3193 phone->GetNumber().c_str()
3194 );
3195
3196 delete phone;
3197 phone = vcard.GetNextPhoneNumber(&cookie);
3198 }
3199}
3200
3201static void TestVCardRead()
3202{
456ae26d 3203 wxPuts(_T("*** Testing wxVCard reading ***\n"));
f6bcfd97
BP
3204
3205 wxVCard vcard(_T("vcard.vcf"));
3206 if ( !vcard.IsOk() )
3207 {
456ae26d 3208 wxPuts(_T("ERROR: couldn't load vCard."));
f6bcfd97
BP
3209 }
3210 else
3211 {
3212 // read individual vCard properties
3213 wxVCardObject *vcObj = vcard.GetProperty("FN");
3214 wxString value;
3215 if ( vcObj )
3216 {
3217 vcObj->GetValue(&value);
3218 delete vcObj;
3219 }
3220 else
3221 {
3222 value = _T("<none>");
3223 }
3224
456ae26d 3225 wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
f6bcfd97
BP
3226
3227
3228 if ( !vcard.GetFullName(&value) )
3229 {
3230 value = _T("<none>");
3231 }
3232
456ae26d 3233 wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
f6bcfd97 3234
3103e8a9 3235 // now show how to deal with multiply occurring properties
f6bcfd97
BP
3236 DumpVCardAddresses(vcard);
3237 DumpVCardPhoneNumbers(vcard);
3238
3239 // and finally show all
456ae26d 3240 wxPuts(_T("\nNow dumping the entire vCard:\n")
f6bcfd97
BP
3241 "-----------------------------\n");
3242
3243 DumpVObject(0, vcard);
3244 }
3245}
3246
3247static void TestVCardWrite()
3248{
456ae26d 3249 wxPuts(_T("*** Testing wxVCard writing ***\n"));
f6bcfd97
BP
3250
3251 wxVCard vcard;
3252 if ( !vcard.IsOk() )
3253 {
456ae26d 3254 wxPuts(_T("ERROR: couldn't create vCard."));
f6bcfd97
BP
3255 }
3256 else
3257 {
3258 // set some fields
3259 vcard.SetName("Zeitlin", "Vadim");
3260 vcard.SetFullName("Vadim Zeitlin");
be5a51fb 3261 vcard.SetOrganization("wxWidgets", "R&D");
f6bcfd97
BP
3262
3263 // just dump the vCard back
456ae26d
VZ
3264 wxPuts(_T("Entire vCard follows:\n"));
3265 wxPuts(vcard.Write());
f6bcfd97
BP
3266 }
3267}
3268
3269#endif // TEST_VCARD
3270
0e2c5534
VZ
3271// ----------------------------------------------------------------------------
3272// wxVolume tests
3273// ----------------------------------------------------------------------------
3274
ba6ea19e 3275#if !defined(__WIN32__) || !wxUSE_FSVOLUME
0e2c5534
VZ
3276 #undef TEST_VOLUME
3277#endif
3278
3279#ifdef TEST_VOLUME
3280
3281#include "wx/volume.h"
3282
3283static const wxChar *volumeKinds[] =
3284{
3285 _T("floppy"),
3286 _T("hard disk"),
3287 _T("CD-ROM"),
3288 _T("DVD-ROM"),
3289 _T("network volume"),
3290 _T("other volume"),
3291};
3292
3293static void TestFSVolume()
3294{
3295 wxPuts(_T("*** Testing wxFSVolume class ***"));
3296
3297 wxArrayString volumes = wxFSVolume::GetVolumes();
3298 size_t count = volumes.GetCount();
3299
3300 if ( !count )
3301 {
3302 wxPuts(_T("ERROR: no mounted volumes?"));
3303 return;
3304 }
3305
3306 wxPrintf(_T("%u mounted volumes found:\n"), count);
3307
3308 for ( size_t n = 0; n < count; n++ )
3309 {
3310 wxFSVolume vol(volumes[n]);
3311 if ( !vol.IsOk() )
3312 {
3313 wxPuts(_T("ERROR: couldn't create volume"));
3314 continue;
3315 }
3316
3317 wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3318 n + 1,
3319 vol.GetDisplayName().c_str(),
3320 vol.GetName().c_str(),
3321 volumeKinds[vol.GetKind()],
3322 vol.IsWritable() ? _T("rw") : _T("ro"),
3323 vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3324 : _T("fixed"));
3325 }
3326}
3327
3328#endif // TEST_VOLUME
3329
f6bcfd97 3330// ----------------------------------------------------------------------------
e7d41190 3331// wide char and Unicode support
f6bcfd97
BP
3332// ----------------------------------------------------------------------------
3333
3334#ifdef TEST_WCHAR
3335
e84010cf
GD
3336#include "wx/strconv.h"
3337#include "wx/fontenc.h"
3338#include "wx/encconv.h"
3339#include "wx/buffer.h"
f6bcfd97 3340
2b5f62a0 3341static const unsigned char utf8koi8r[] =
ac511156
VZ
3342{
3343 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3344 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3345 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3346 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3347 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3348 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3349 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3350};
3351
2b5f62a0
VZ
3352static const unsigned char utf8iso8859_1[] =
3353{
3354 0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3355 0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3356 0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3357 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3358 0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3359};
3360
3361static const unsigned char utf8Invalid[] =
3362{
3363 0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3364 0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3365 0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3366 0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3367 0x6c, 0x61, 0x79, 0
3368};
3369
3370static const struct Utf8Data
3371{
3372 const unsigned char *text;
3373 size_t len;
3374 const wxChar *charset;
3375 wxFontEncoding encoding;
3376} utf8data[] =
3377{
3378 { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3379 { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3380 { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3381};
456ae26d 3382
f6bcfd97
BP
3383static void TestUtf8()
3384{
456ae26d 3385 wxPuts(_T("*** Testing UTF8 support ***\n"));
f6bcfd97 3386
24f25c8a
VZ
3387 char buf[1024];
3388 wchar_t wbuf[1024];
2b5f62a0
VZ
3389
3390 for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
24f25c8a 3391 {
2b5f62a0
VZ
3392 const Utf8Data& u8d = utf8data[n];
3393 if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3394 WXSIZEOF(wbuf)) == (size_t)-1 )
24f25c8a 3395 {
2b5f62a0 3396 wxPuts(_T("ERROR: UTF-8 decoding failed."));
24f25c8a
VZ
3397 }
3398 else
ac511156 3399 {
2b5f62a0
VZ
3400 wxCSConv conv(u8d.charset);
3401 if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3402 {
3403 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3404 }
3405 else
3406 {
3407 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3408 }
ac511156 3409 }
ac511156 3410
5bc1deeb 3411 wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
2b5f62a0
VZ
3412 if ( s.empty() )
3413 s = _T("<< conversion failed >>");
3414 wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3415
ac511156
VZ
3416 }
3417
e9d2bb6f 3418 wxPuts(wxEmptyString);
ac511156 3419}
f6bcfd97 3420
ac511156
VZ
3421static void TestEncodingConverter()
3422{
3423 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3424
3425 // using wxEncodingConverter should give the same result as above
3426 char buf[1024];
3427 wchar_t wbuf[1024];
2b5f62a0
VZ
3428 if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
3429 WXSIZEOF(utf8koi8r)) == (size_t)-1 )
ac511156 3430 {
456ae26d 3431 wxPuts(_T("ERROR: UTF-8 decoding failed."));
ac511156
VZ
3432 }
3433 else
3434 {
3435 wxEncodingConverter ec;
3436 ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3437 ec.Convert(wbuf, buf);
2b5f62a0 3438 wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
24f25c8a 3439 }
ac511156 3440
e9d2bb6f 3441 wxPuts(wxEmptyString);
f6bcfd97
BP
3442}
3443
3444#endif // TEST_WCHAR
3445
3446// ----------------------------------------------------------------------------
3447// ZIP stream
3448// ----------------------------------------------------------------------------
3449
3450#ifdef TEST_ZIP
3451
2ca8b884
VZ
3452#include "wx/filesys.h"
3453#include "wx/fs_zip.h"
f6bcfd97
BP
3454#include "wx/zipstrm.h"
3455
2ca8b884
VZ
3456static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3457
f6bcfd97
BP
3458static void TestZipStreamRead()
3459{
456ae26d 3460 wxPuts(_T("*** Testing ZIP reading ***\n"));
f6bcfd97 3461
e9d2bb6f 3462 static const wxString filename = _T("foo");
bf3bf677 3463 wxFFileInputStream in(TESTFILE_ZIP);
3e231024 3464 wxZipInputStream istr(in);
bf3bf677
VZ
3465 wxZipEntry entry(filename);
3466 istr.OpenEntry(entry);
3467
456ae26d 3468 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
f6bcfd97 3469
e9d2bb6f 3470 wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
eb835127
FM
3471 int c;
3472 while ( (c=istr.GetC()) != wxEOF )
f6bcfd97 3473 {
eb835127 3474 wxPutchar(c);
f6bcfd97
BP
3475 fflush(stdout);
3476 }
3477
456ae26d 3478 wxPuts(_T("\n----- done ------"));
f6bcfd97
BP
3479}
3480
2ca8b884
VZ
3481static void DumpZipDirectory(wxFileSystem& fs,
3482 const wxString& dir,
3483 const wxString& indent)
3484{
3485 wxString prefix = wxString::Format(_T("%s#zip:%s"),
3486 TESTFILE_ZIP, dir.c_str());
3487 wxString wildcard = prefix + _T("/*");
3488
3489 wxString dirname = fs.FindFirst(wildcard, wxDIR);
3490 while ( !dirname.empty() )
3491 {
3492 if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3493 {
3494 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3495
3496 break;
3497 }
3498
3499 wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3500
3501 DumpZipDirectory(fs, dirname,
3502 indent + wxString(_T(' '), 4));
3503
3504 dirname = fs.FindNext();
3505 }
3506
3507 wxString filename = fs.FindFirst(wildcard, wxFILE);
3508 while ( !filename.empty() )
3509 {
3510 if ( !filename.StartsWith(prefix, &filename) )
3511 {
3512 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3513
3514 break;
3515 }
3516
3517 wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3518
3519 filename = fs.FindNext();
3520 }
3521}
3522
3523static void TestZipFileSystem()
3524{
456ae26d 3525 wxPuts(_T("*** Testing ZIP file system ***\n"));
2ca8b884
VZ
3526
3527 wxFileSystem::AddHandler(new wxZipFSHandler);
3528 wxFileSystem fs;
3529 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3530
3531 DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3532}
3533
f6bcfd97
BP
3534#endif // TEST_ZIP
3535
b76b015e
VZ
3536// ----------------------------------------------------------------------------
3537// date time
3538// ----------------------------------------------------------------------------
3539
d31b7b68 3540#ifdef TEST_DATETIME
b76b015e 3541
b713f891 3542#include "wx/math.h"
e84010cf 3543#include "wx/datetime.h"
b76b015e 3544
2f02cb89 3545// this test miscellaneous static wxDateTime functions
4b586201
WS
3546
3547#if TEST_ALL
3548
2f02cb89
VZ
3549static void TestTimeStatic()
3550{
456ae26d 3551 wxPuts(_T("\n*** wxDateTime static methods test ***"));
2f02cb89
VZ
3552
3553 // some info about the current date
3554 int year = wxDateTime::GetCurrentYear();
456ae26d 3555 wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
2f02cb89
VZ
3556 year,
3557 wxDateTime::IsLeapYear(year) ? "" : "not ",
3558 wxDateTime::GetNumberOfDays(year));
3559
3560 wxDateTime::Month month = wxDateTime::GetCurrentMonth();
456ae26d 3561 wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
f0f951fa 3562 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
2f02cb89
VZ
3563 wxDateTime::GetMonthName(month).c_str(),
3564 wxDateTime::GetNumberOfDays(month));
2f02cb89
VZ
3565}
3566
fcc3d7cb
VZ
3567// test time zones stuff
3568static void TestTimeZones()
3569{
456ae26d 3570 wxPuts(_T("\n*** wxDateTime timezone test ***"));
fcc3d7cb
VZ
3571
3572 wxDateTime now = wxDateTime::Now();
3573
456ae26d
VZ
3574 wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
3575 wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
3576 wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
3577 wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
3578 wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
3579 wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
9d9b7755 3580
ccd6aacd
VZ
3581 wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3582
9d9b7755
VZ
3583 wxDateTime::Tm tm = now.GetTm();
3584 if ( wxDateTime(tm) != now )
3585 {
456ae26d
VZ
3586 wxPrintf(_T("ERROR: got %s instead of %s\n"),
3587 wxDateTime(tm).Format().c_str(), now.Format().c_str());
9d9b7755 3588 }
fcc3d7cb
VZ
3589}
3590
e6ec579c
VZ
3591// test some minimal support for the dates outside the standard range
3592static void TestTimeRange()
3593{
456ae26d 3594 wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
e6ec579c 3595
456ae26d 3596 static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
211c2250 3597
456ae26d
VZ
3598 wxPrintf(_T("Unix epoch:\t%s\n"),
3599 wxDateTime(2440587.5).Format(fmt).c_str());
3600 wxPrintf(_T("Feb 29, 0: \t%s\n"),
3601 wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3602 wxPrintf(_T("JDN 0: \t%s\n"),
3603 wxDateTime(0.0).Format(fmt).c_str());
3604 wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3605 wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3606 wxPrintf(_T("May 29, 2099:\t%s\n"),
3607 wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
e6ec579c
VZ
3608}
3609
239446b4
VZ
3610// test DST calculations
3611static void TestTimeDST()
3612{
456ae26d 3613 wxPuts(_T("\n*** wxDateTime DST test ***"));
239446b4 3614
456ae26d 3615 wxPrintf(_T("DST is%s in effect now.\n\n"),
e9d2bb6f 3616 wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
239446b4 3617
ccd6aacd 3618 for ( int year = 1990; year < 2005; year++ )
239446b4 3619 {
456ae26d
VZ
3620 wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3621 year,
3622 wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3623 wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
239446b4
VZ
3624 }
3625}
3626
4b586201
WS
3627#endif // TEST_ALL
3628
3629#if TEST_INTERACTIVE
3630
b92fd37c 3631static void TestDateTimeInteractive()
9d9b7755 3632{
456ae26d 3633 wxPuts(_T("\n*** interactive wxDateTime tests ***"));
9d9b7755 3634
456ae26d 3635 wxChar buf[128];
9d9b7755
VZ
3636
3637 for ( ;; )
3638 {
456ae26d
VZ
3639 wxPrintf(_T("Enter a date: "));
3640 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
9d9b7755
VZ
3641 break;
3642
f6bcfd97 3643 // kill the last '\n'
456ae26d 3644 buf[wxStrlen(buf) - 1] = 0;
f6bcfd97 3645
9d9b7755 3646 wxDateTime dt;
456ae26d 3647 const wxChar *p = dt.ParseDate(buf);
f6bcfd97 3648 if ( !p )
9d9b7755 3649 {
456ae26d 3650 wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
9d9b7755
VZ
3651
3652 continue;
3653 }
f6bcfd97
BP
3654 else if ( *p )
3655 {
456ae26d 3656 wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
f6bcfd97 3657 }
9d9b7755 3658
456ae26d
VZ
3659 wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3660 dt.Format(_T("%b %d, %Y")).c_str(),
3661 dt.GetDayOfYear(),
3662 dt.GetWeekOfMonth(wxDateTime::Monday_First),
3663 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3664 dt.GetWeekOfYear(wxDateTime::Monday_First));
9d9b7755
VZ
3665 }
3666
456ae26d 3667 wxPuts(_T("\n*** done ***"));
9d9b7755
VZ
3668}
3669
4b586201
WS
3670#endif // TEST_INTERACTIVE
3671
3672#if TEST_ALL
3673
f6bcfd97
BP
3674static void TestTimeMS()
3675{
456ae26d 3676 wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
f6bcfd97
BP
3677
3678 wxDateTime dt1 = wxDateTime::Now(),
3679 dt2 = wxDateTime::UNow();
3680
456ae26d
VZ
3681 wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
3682 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3683 wxPrintf(_T("Dummy loop: "));
3ca6a5f0
BP
3684 for ( int i = 0; i < 6000; i++ )
3685 {
3686 //for ( int j = 0; j < 10; j++ )
3687 {
3688 wxString s;
ccd6aacd 3689 s.Printf(_T("%g"), sqrt((float)i));
3ca6a5f0
BP
3690 }
3691
3692 if ( !(i % 100) )
e9d2bb6f 3693 wxPutchar('.');
3ca6a5f0 3694 }
456ae26d 3695 wxPuts(_T(", done"));
3ca6a5f0
BP
3696
3697 dt1 = dt2;
3698 dt2 = wxDateTime::UNow();
456ae26d 3699 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3ca6a5f0 3700
456ae26d 3701 wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
f6bcfd97 3702
456ae26d 3703 wxPuts(_T("\n*** done ***"));
f6bcfd97
BP
3704}
3705
0de868d9
VZ
3706static void TestTimeHolidays()
3707{
456ae26d 3708 wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
0de868d9
VZ
3709
3710 wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3711 wxDateTime dtStart(1, tm.mon, tm.year),
3712 dtEnd = dtStart.GetLastMonthDay();
3713
3714 wxDateTimeArray hol;
3715 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3716
456ae26d 3717 const wxChar *format = _T("%d-%b-%Y (%a)");
0de868d9 3718
456ae26d 3719 wxPrintf(_T("All holidays between %s and %s:\n"),
0de868d9
VZ
3720 dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3721
3722 size_t count = hol.GetCount();
3723 for ( size_t n = 0; n < count; n++ )
3724 {
456ae26d 3725 wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
0de868d9
VZ
3726 }
3727
e9d2bb6f 3728 wxPuts(wxEmptyString);
0de868d9
VZ
3729}
3730
f6bcfd97
BP
3731static void TestTimeZoneBug()
3732{
456ae26d 3733 wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
f6bcfd97
BP
3734
3735 wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3736 for ( int i = 0; i < 31; i++ )
3737 {
456ae26d 3738 wxPrintf(_T("Date %s: week day %s.\n"),
f6bcfd97
BP
3739 date.Format(_T("%d-%m-%Y")).c_str(),
3740 date.GetWeekDayName(date.GetWeekDay()).c_str());
3741
3742 date += wxDateSpan::Day();
3743 }
3744
e9d2bb6f 3745 wxPuts(wxEmptyString);
f6bcfd97
BP
3746}
3747
df05cdc5
VZ
3748static void TestTimeSpanFormat()
3749{
456ae26d 3750 wxPuts(_T("\n*** wxTimeSpan tests ***"));
df05cdc5 3751
456ae26d 3752 static const wxChar *formats[] =
df05cdc5
VZ
3753 {
3754 _T("(default) %H:%M:%S"),
3755 _T("%E weeks and %D days"),
3756 _T("%l milliseconds"),
3757 _T("(with ms) %H:%M:%S:%l"),
3758 _T("100%% of minutes is %M"), // test "%%"
3759 _T("%D days and %H hours"),
a8625337 3760 _T("or also %S seconds"),
df05cdc5
VZ
3761 };
3762
3763 wxTimeSpan ts1(1, 2, 3, 4),
3764 ts2(111, 222, 333);
3765 for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3766 {
456ae26d 3767 wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
df05cdc5
VZ
3768 ts1.Format(formats[n]).c_str(),
3769 ts2.Format(formats[n]).c_str());
3770 }
3771
e9d2bb6f 3772 wxPuts(wxEmptyString);
df05cdc5
VZ
3773}
3774
4b586201
WS
3775#endif // TEST_ALL
3776
d31b7b68 3777#endif // TEST_DATETIME
b76b015e 3778
39937656
VZ
3779// ----------------------------------------------------------------------------
3780// wxTextInput/OutputStream
3781// ----------------------------------------------------------------------------
3782
3783#ifdef TEST_TEXTSTREAM
3784
3785#include "wx/txtstrm.h"
3786#include "wx/wfstream.h"
3787
3788static void TestTextInputStream()
3789{
3790 wxPuts(_T("\n*** wxTextInputStream test ***"));
3791
e9d2bb6f
DS
3792 wxString filename = _T("testdata.fc");
3793 wxFileInputStream fsIn(filename);
39937656
VZ
3794 if ( !fsIn.Ok() )
3795 {
3796 wxPuts(_T("ERROR: couldn't open file."));
3797 }
3798 else
3799 {
3800 wxTextInputStream tis(fsIn);
3801
3802 size_t line = 1;
3803 for ( ;; )
3804 {
3805 const wxString s = tis.ReadLine();
3806
3807 // line could be non empty if the last line of the file isn't
3808 // terminated with EOL
3809 if ( fsIn.Eof() && s.empty() )
3810 break;
3811
3812 wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
3813 }
3814 }
3815}
3816
3817#endif // TEST_TEXTSTREAM
3818
e87271f3
VZ
3819// ----------------------------------------------------------------------------
3820// threads
3821// ----------------------------------------------------------------------------
3822
3823#ifdef TEST_THREADS
3824
e84010cf 3825#include "wx/thread.h"
37667812 3826
bbfa0322
VZ
3827static size_t gs_counter = (size_t)-1;
3828static wxCriticalSection gs_critsect;
c112e100 3829static wxSemaphore gs_cond;
bbfa0322 3830
b568d04f 3831class MyJoinableThread : public wxThread
bbfa0322
VZ
3832{
3833public:
b568d04f
VZ
3834 MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3835 { m_n = n; Create(); }
bbfa0322
VZ
3836
3837 // thread execution starts here
b568d04f 3838 virtual ExitCode Entry();
bbfa0322 3839
b568d04f
VZ
3840private:
3841 size_t m_n;
bbfa0322
VZ
3842};
3843
b568d04f 3844wxThread::ExitCode MyJoinableThread::Entry()
bbfa0322 3845{
b568d04f
VZ
3846 unsigned long res = 1;
3847 for ( size_t n = 1; n < m_n; n++ )
3848 {
3849 res *= n;
3850
3851 // it's a loooong calculation :-)
3852 Sleep(100);
3853 }
bbfa0322 3854
b568d04f 3855 return (ExitCode)res;
bbfa0322
VZ
3856}
3857
b568d04f
VZ
3858class MyDetachedThread : public wxThread
3859{
3860public:
456ae26d 3861 MyDetachedThread(size_t n, wxChar ch)
fcc3d7cb
VZ
3862 {
3863 m_n = n;
3864 m_ch = ch;
cab8f76e 3865 m_cancelled = false;
fcc3d7cb
VZ
3866
3867 Create();
3868 }
b568d04f
VZ
3869
3870 // thread execution starts here
3871 virtual ExitCode Entry();
3872
3873 // and stops here
3874 virtual void OnExit();
3875
3876private:
9fc3ad34 3877 size_t m_n; // number of characters to write
456ae26d 3878 wxChar m_ch; // character to write
fcc3d7cb 3879
cab8f76e 3880 bool m_cancelled; // false if we exit normally
b568d04f
VZ
3881};
3882
3883wxThread::ExitCode MyDetachedThread::Entry()
bbfa0322
VZ
3884{
3885 {
3886 wxCriticalSectionLocker lock(gs_critsect);
3887 if ( gs_counter == (size_t)-1 )
3888 gs_counter = 1;
3889 else
3890 gs_counter++;
3891 }
3892
9fc3ad34 3893 for ( size_t n = 0; n < m_n; n++ )
bbfa0322
VZ
3894 {
3895 if ( TestDestroy() )
fcc3d7cb 3896 {
cab8f76e 3897 m_cancelled = true;
fcc3d7cb 3898
bbfa0322 3899 break;
fcc3d7cb 3900 }
bbfa0322 3901
e9d2bb6f 3902 wxPutchar(m_ch);
bbfa0322
VZ
3903 fflush(stdout);
3904
3905 wxThread::Sleep(100);
3906 }
3907
b568d04f 3908 return 0;
bbfa0322
VZ
3909}
3910
b568d04f 3911void MyDetachedThread::OnExit()
bbfa0322 3912{
456ae26d 3913 wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
9fc3ad34 3914
bbfa0322 3915 wxCriticalSectionLocker lock(gs_critsect);
fcc3d7cb 3916 if ( !--gs_counter && !m_cancelled )
c112e100 3917 gs_cond.Post();
bbfa0322
VZ
3918}
3919
2f2f3e2a 3920static void TestDetachedThreads()
9fc3ad34 3921{
456ae26d 3922 wxPuts(_T("\n*** Testing detached threads ***"));
9fc3ad34
VZ
3923
3924 static const size_t nThreads = 3;
3925 MyDetachedThread *threads[nThreads];
3926 size_t n;
3927 for ( n = 0; n < nThreads; n++ )
3928 {
3929 threads[n] = new MyDetachedThread(10, 'A' + n);
3930 }
3931
3932 threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
3933 threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
3934
3935 for ( n = 0; n < nThreads; n++ )
3936 {
3937 threads[n]->Run();
3938 }
3939
3940 // wait until all threads terminate
3941 gs_cond.Wait();
3942
e9d2bb6f 3943 wxPuts(wxEmptyString);
9fc3ad34
VZ
3944}
3945
2f2f3e2a 3946static void TestJoinableThreads()
9fc3ad34 3947{
456ae26d 3948 wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
9fc3ad34
VZ
3949
3950 // calc 10! in the background
3951 MyJoinableThread thread(10);
3952 thread.Run();
3953
456ae26d 3954 wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
5bc1deeb 3955 (unsigned long)thread.Wait());
9fc3ad34
VZ
3956}
3957
2f2f3e2a 3958static void TestThreadSuspend()
9fc3ad34 3959{
456ae26d 3960 wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
2f02cb89
VZ
3961
3962 MyDetachedThread *thread = new MyDetachedThread(15, 'X');
9fc3ad34
VZ
3963
3964 thread->Run();
3965
3966 // this is for this demo only, in a real life program we'd use another
3967 // condition variable which would be signaled from wxThread::Entry() to
3968 // tell us that the thread really started running - but here just wait a
3969 // bit and hope that it will be enough (the problem is, of course, that
3970 // the thread might still not run when we call Pause() which will result
3971 // in an error)
3972 wxThread::Sleep(300);
3973
3974 for ( size_t n = 0; n < 3; n++ )
3975 {
3976 thread->Pause();
3977
456ae26d 3978 wxPuts(_T("\nThread suspended"));
9fc3ad34
VZ
3979 if ( n > 0 )
3980 {
3981 // don't sleep but resume immediately the first time
3982 wxThread::Sleep(300);
3983 }
456ae26d 3984 wxPuts(_T("Going to resume the thread"));
9fc3ad34
VZ
3985
3986 thread->Resume();
3987 }
3988
456ae26d 3989 wxPuts(_T("Waiting until it terminates now"));
4c460b34 3990
9fc3ad34
VZ
3991 // wait until the thread terminates
3992 gs_cond.Wait();
3993
e9d2bb6f 3994 wxPuts(wxEmptyString);
9fc3ad34
VZ
3995}
3996
2f2f3e2a 3997static void TestThreadDelete()
2f02cb89
VZ
3998{
3999 // As above, using Sleep() is only for testing here - we must use some
4000 // synchronisation object instead to ensure that the thread is still
4001 // running when we delete it - deleting a detached thread which already
4002 // terminated will lead to a crash!
4003
456ae26d 4004 wxPuts(_T("\n*** Testing thread delete function ***"));
2f02cb89 4005
4c460b34
VZ
4006 MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
4007
4008 thread0->Delete();
4009
456ae26d 4010 wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
4c460b34 4011
2f02cb89
VZ
4012 MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
4013
4014 thread1->Run();
4015
4016 wxThread::Sleep(300);
4017
4018 thread1->Delete();
4019
456ae26d 4020 wxPuts(_T("\nDeleted a running thread."));
2f02cb89
VZ
4021
4022 MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
4023
4024 thread2->Run();
4025
4026 wxThread::Sleep(300);
4027
4028 thread2->Pause();
4029
4030 thread2->Delete();
4031
456ae26d 4032 wxPuts(_T("\nDeleted a sleeping thread."));
2f02cb89 4033
4c460b34
VZ
4034 MyJoinableThread thread3(20);
4035 thread3.Run();
2f02cb89 4036
4c460b34 4037 thread3.Delete();
2f02cb89 4038
456ae26d 4039 wxPuts(_T("\nDeleted a joinable thread."));
2f02cb89 4040
4c460b34
VZ
4041 MyJoinableThread thread4(2);
4042 thread4.Run();
2f02cb89
VZ
4043
4044 wxThread::Sleep(300);
4045
4c460b34 4046 thread4.Delete();
2f02cb89 4047
456ae26d 4048 wxPuts(_T("\nDeleted a joinable thread which already terminated."));
2f02cb89 4049
e9d2bb6f 4050 wxPuts(wxEmptyString);
2f02cb89
VZ
4051}
4052
2f2f3e2a
VZ
4053class MyWaitingThread : public wxThread
4054{
4055public:
c112e100 4056 MyWaitingThread( wxMutex *mutex, wxCondition *condition )
2f2f3e2a 4057 {
c112e100 4058 m_mutex = mutex;
2f2f3e2a
VZ
4059 m_condition = condition;
4060
4061 Create();
4062 }
4063
4064 virtual ExitCode Entry()
4065 {
456ae26d 4066 wxPrintf(_T("Thread %lu has started running.\n"), GetId());
2f2f3e2a
VZ
4067 fflush(stdout);
4068
c112e100 4069 gs_cond.Post();
2f2f3e2a 4070
456ae26d 4071 wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
2f2f3e2a
VZ
4072 fflush(stdout);
4073
c112e100 4074 m_mutex->Lock();
2f2f3e2a 4075 m_condition->Wait();
c112e100 4076 m_mutex->Unlock();
2f2f3e2a 4077
456ae26d 4078 wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
2f2f3e2a
VZ
4079 fflush(stdout);
4080
4081 return 0;
4082 }
4083
4084private:
c112e100 4085 wxMutex *m_mutex;
2f2f3e2a
VZ
4086 wxCondition *m_condition;
4087};
4088
4089static void TestThreadConditions()
4090{
c112e100
VZ
4091 wxMutex mutex;
4092 wxCondition condition(mutex);
2f2f3e2a 4093
8d5eff60
VZ
4094 // otherwise its difficult to understand which log messages pertain to
4095 // which condition
456ae26d 4096 //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
c112e100 4097 // condition.GetId(), gs_cond.GetId());
8d5eff60 4098
2f2f3e2a 4099 // create and launch threads
60ce696e 4100 MyWaitingThread *threads[10];
2f2f3e2a
VZ
4101
4102 size_t n;
4103 for ( n = 0; n < WXSIZEOF(threads); n++ )
4104 {
c112e100 4105 threads[n] = new MyWaitingThread( &mutex, &condition );
2f2f3e2a
VZ
4106 }
4107
4108 for ( n = 0; n < WXSIZEOF(threads); n++ )
4109 {
4110 threads[n]->Run();
4111 }
4112
4113 // wait until all threads run
456ae26d 4114 wxPuts(_T("Main thread is waiting for the other threads to start"));
2f2f3e2a
VZ
4115 fflush(stdout);
4116
4117 size_t nRunning = 0;
4118 while ( nRunning < WXSIZEOF(threads) )
4119 {
4120 gs_cond.Wait();
4121
2f2f3e2a 4122 nRunning++;
8d5eff60 4123
456ae26d 4124 wxPrintf(_T("Main thread: %u already running\n"), nRunning);
8d5eff60 4125 fflush(stdout);
2f2f3e2a
VZ
4126 }
4127
456ae26d 4128 wxPuts(_T("Main thread: all threads started up."));
2f2f3e2a
VZ
4129 fflush(stdout);
4130
8d5eff60
VZ
4131 wxThread::Sleep(500);
4132
60ce696e 4133#if 1
8d5eff60 4134 // now wake one of them up
456ae26d 4135 wxPrintf(_T("Main thread: about to signal the condition.\n"));
2f2f3e2a
VZ
4136 fflush(stdout);
4137 condition.Signal();
8d5eff60 4138#endif
2f2f3e2a 4139
60ce696e
VZ
4140 wxThread::Sleep(200);
4141
8d5eff60 4142 // wake all the (remaining) threads up, so that they can exit
456ae26d 4143 wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
2f2f3e2a
VZ
4144 fflush(stdout);
4145 condition.Broadcast();
4146
8d5eff60
VZ
4147 // give them time to terminate (dirty!)
4148 wxThread::Sleep(500);
2f2f3e2a
VZ
4149}
4150
c112e100
VZ
4151// semaphore tests
4152#include "wx/datetime.h"
4153
4154class MySemaphoreThread : public wxThread
4155{
4156public:
4157 MySemaphoreThread(int i, wxSemaphore *sem)
4158 : wxThread(wxTHREAD_JOINABLE),
4159 m_sem(sem),
4160 m_i(i)
4161 {
4162 Create();
4163 }
4164
4165 virtual ExitCode Entry()
4166 {
f06ef5f4
VZ
4167 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
4168 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
c112e100
VZ
4169
4170 m_sem->Wait();
4171
f06ef5f4
VZ
4172 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
4173 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
c112e100
VZ
4174
4175 Sleep(1000);
4176
f06ef5f4
VZ
4177 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
4178 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
c112e100
VZ
4179
4180 m_sem->Post();
4181
4182 return 0;
4183 }
4184
4185private:
4186 wxSemaphore *m_sem;
4187 int m_i;
4188};
4189
e9d2bb6f 4190WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
c112e100
VZ
4191
4192static void TestSemaphore()
4193{
4194 wxPuts(_T("*** Testing wxSemaphore class. ***"));
4195
4196 static const int SEM_LIMIT = 3;
4197
4198 wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
4199 ArrayThreads threads;
4200
4201 for ( int i = 0; i < 3*SEM_LIMIT; i++ )
4202 {
4203 threads.Add(new MySemaphoreThread(i, &sem));
4204 threads.Last()->Run();
4205 }
4206
4207 for ( size_t n = 0; n < threads.GetCount(); n++ )
4208 {
4209 threads[n]->Wait();
4210 delete threads[n];
4211 }
4212}
4213
e87271f3
VZ
4214#endif // TEST_THREADS
4215
e87271f3
VZ
4216// ----------------------------------------------------------------------------
4217// entry point
4218// ----------------------------------------------------------------------------
4219
daa2c7d9
VZ
4220#ifdef TEST_SNGLINST
4221 #include "wx/snglinst.h"
4222#endif // TEST_SNGLINST
4223
bbfa0322 4224int main(int argc, char **argv)
37667812 4225{
5ba95b79
WS
4226#if wxUSE_UNICODE
4227 wxChar **wxArgv = new wxChar *[argc + 1];
4228
4229 {
4230 int n;
4231
4232 for (n = 0; n < argc; n++ )
4233 {
4234 wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
4235 wxArgv[n] = wxStrdup(warg);
4236 }
4237
4238 wxArgv[n] = NULL;
4239 }
4240#else // !wxUSE_UNICODE
4241 #define wxArgv argv
4242#endif // wxUSE_UNICODE/!wxUSE_UNICODE
4243
6f35ed60 4244 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
9cb47ea2 4245
58b24a56
VZ
4246 wxInitializer initializer;
4247 if ( !initializer )
37667812 4248 {
be5a51fb 4249 fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
58b24a56
VZ
4250
4251 return -1;
4252 }
4253
4254#ifdef TEST_SNGLINST
b5299791
VZ
4255 wxSingleInstanceChecker checker;
4256 if ( checker.Create(_T(".wxconsole.lock")) )
58b24a56 4257 {
b5299791
VZ
4258 if ( checker.IsAnotherRunning() )
4259 {
4260 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
58b24a56 4261
b5299791
VZ
4262 return 1;
4263 }
37667812 4264
b5299791
VZ
4265 // wait some time to give time to launch another instance
4266 wxPrintf(_T("Press \"Enter\" to continue..."));
4267 wxFgetc(stdin);
4268 }
4269 else // failed to create
4270 {
4271 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
4272 }
58b24a56
VZ
4273#endif // TEST_SNGLINST
4274
d34bce84 4275#ifdef TEST_CMDLINE
31f6de22
VZ
4276 TestCmdLineConvert();
4277
4278#if wxUSE_CMDLINE_PARSER
d34bce84
VZ
4279 static const wxCmdLineEntryDesc cmdLineDesc[] =
4280 {
50c549b9 4281 { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
31a06b07 4282 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
50c549b9
VZ
4283 { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
4284 { wxCMD_LINE_SWITCH, "q", "quiet", "be quiet" },
d34bce84 4285
50c549b9
VZ
4286 { wxCMD_LINE_OPTION, "o", "output", "output file" },
4287 { wxCMD_LINE_OPTION, "i", "input", "input dir" },
4288 { wxCMD_LINE_OPTION, "s", "size", "output block size",
31a06b07 4289 wxCMD_LINE_VAL_NUMBER },
50c549b9 4290 { wxCMD_LINE_OPTION, "d", "date", "output file date",
31a06b07 4291 wxCMD_LINE_VAL_DATE },
b1859b1a
VZ
4292 { wxCMD_LINE_OPTION, "f", "double", "output double",
4293 wxCMD_LINE_VAL_DOUBLE },
d34bce84 4294
50c549b9 4295 { wxCMD_LINE_PARAM, NULL, NULL, "input file",
d34bce84
VZ
4296 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
4297
4298 { wxCMD_LINE_NONE }
4299 };
4300
5ba95b79 4301 wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
456ae26d
VZ
4302
4303 parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
f6bcfd97
BP
4304 wxCMD_LINE_VAL_STRING,
4305 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
4306
d34bce84
VZ
4307 switch ( parser.Parse() )
4308 {
4309 case -1:
456ae26d 4310 wxLogMessage(_T("Help was given, terminating."));
d34bce84
VZ
4311 break;
4312
4313 case 0:
4314 ShowCmdLine(parser);
4315 break;
4316
4317 default:
456ae26d 4318 wxLogMessage(_T("Syntax error detected, aborting."));
d34bce84
VZ
4319 break;
4320 }
31f6de22
VZ
4321#endif // wxUSE_CMDLINE_PARSER
4322
d34bce84
VZ
4323#endif // TEST_CMDLINE
4324
1944c6bd 4325#ifdef TEST_DIR
e9d2bb6f 4326 #if TEST_ALL
99a5af7f 4327 TestDirExists();
2f0c19d0 4328 TestDirEnum();
e9d2bb6f 4329 #endif
2f0c19d0 4330 TestDirTraverse();
1944c6bd
VZ
4331#endif // TEST_DIR
4332
93ed8ff7 4333#ifdef TEST_DYNLIB
f6bcfd97 4334 TestDllLoad();
297ebe6b 4335 TestDllListLoaded();
93ed8ff7 4336#endif // TEST_DYNLIB
f6bcfd97 4337
8fd0d89b
VZ
4338#ifdef TEST_ENVIRON
4339 TestEnvironment();
4340#endif // TEST_ENVIRON
4341
d93c719a
VZ
4342#ifdef TEST_EXECUTE
4343 TestExecute();
4344#endif // TEST_EXECUTE
4345
ee6e1b1d
VZ
4346#ifdef TEST_FILECONF
4347 TestFileConfRead();
4348#endif // TEST_FILECONF
4349
ec37df57
VZ
4350#ifdef TEST_LOCALE
4351 TestDefaultLang();
4352#endif // TEST_LOCALE
4353
378b05f7 4354#ifdef TEST_LOG
cab8f76e
VZ
4355 wxPuts(_T("*** Testing wxLog ***"));
4356
378b05f7
VZ
4357 wxString s;
4358 for ( size_t n = 0; n < 8000; n++ )
4359 {
456ae26d 4360 s << (wxChar)(_T('A') + (n % 26));
378b05f7
VZ
4361 }
4362
cab8f76e
VZ
4363 wxLogWarning(_T("The length of the string is %lu"),
4364 (unsigned long)s.length());
4365
378b05f7 4366 wxString msg;
456ae26d 4367 msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
378b05f7
VZ
4368
4369 // this one shouldn't be truncated
456ae26d 4370 wxPrintf(msg);
378b05f7
VZ
4371
4372 // but this one will because log functions use fixed size buffer
b568d04f
VZ
4373 // (note that it doesn't need '\n' at the end neither - will be added
4374 // by wxLog anyhow)
456ae26d 4375 wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
378b05f7
VZ
4376#endif // TEST_LOG
4377
f6bcfd97 4378#ifdef TEST_FILE
e9d2bb6f
DS
4379 TestFileRead();
4380 TestTextFileRead();
4381 TestFileCopy();
59062ec1 4382 TestTempFile();
f6bcfd97
BP
4383#endif // TEST_FILE
4384
844f90fb 4385#ifdef TEST_FILENAME
e9d2bb6f
DS
4386 TestFileNameTemp();
4387 TestFileNameCwd();
4388 TestFileNameDirManip();
4389 TestFileNameComparison();
4390 TestFileNameOperations();
844f90fb
VZ
4391#endif // TEST_FILENAME
4392
d56e2b97
VZ
4393#ifdef TEST_FILETIME
4394 TestFileGetTimes();
e9d2bb6f 4395 #if 0
d56e2b97 4396 TestFileSetTimes();
e9d2bb6f 4397 #endif
d56e2b97
VZ
4398#endif // TEST_FILETIME
4399
07a56e45
VZ
4400#ifdef TEST_FTP
4401 wxLog::AddTraceMask(FTP_TRACE_MASK);
eb835127
FM
4402
4403 // wxFTP cannot be a static variable as its ctor needs to access
4404 // wxWidgets internals after it has been initialized
4405 ftp = new wxFTP;
4406
07a56e45
VZ
4407 if ( TestFtpConnect() )
4408 {
e9d2bb6f 4409 #if TEST_ALL
07a56e45
VZ
4410 TestFtpList();
4411 TestFtpDownload();
4412 TestFtpMisc();
daa2c7d9 4413 TestFtpFileSize();
07a56e45 4414 TestFtpUpload();
af33b199 4415 #endif // TEST_ALL
daa2c7d9 4416
e9d2bb6f 4417 #if TEST_INTERACTIVE
eb835127 4418 //TestFtpInteractive();
e9d2bb6f 4419 #endif
07a56e45
VZ
4420 }
4421 //else: connecting to the FTP server failed
4422
eb835127 4423 delete ftp;
07a56e45
VZ
4424#endif // TEST_FTP
4425
696e1ea0 4426#ifdef TEST_MIME
b61af837
VZ
4427 //wxLog::AddTraceMask(_T("mime"));
4428 TestMimeEnum();
c19c2f6e 4429#if 0
b61af837 4430 TestMimeOverride();
c19c2f6e
VZ
4431 TestMimeAssociate();
4432#endif
f06ef5f4 4433 TestMimeFilename();
696e1ea0
VZ
4434#endif // TEST_MIME
4435
89e60357 4436#ifdef TEST_INFO_FUNCTIONS
8bb6b2c0
VZ
4437 TestOsInfo();
4438 TestPlatformInfo();
4439 TestUserInfo();
19f45995 4440
8bb6b2c0
VZ
4441 #if TEST_INTERACTIVE
4442 TestDiskInfo();
e9d2bb6f 4443 #endif
89e60357
VZ
4444#endif // TEST_INFO_FUNCTIONS
4445
39189b9d
VZ
4446#ifdef TEST_PATHLIST
4447 TestPathList();
4448#endif // TEST_PATHLIST
4449
7aeebdcd
VZ
4450#ifdef TEST_PRINTF
4451 TestPrintf();
4452#endif // TEST_PRINTF
4453
7ba4fbeb 4454#ifdef TEST_REGCONF
e9d2bb6f
DS
4455 #if 0
4456 TestRegConfWrite();
4457 #endif
0aa29b6b 4458 TestRegConfRead();
7ba4fbeb
VZ
4459#endif // TEST_REGCONF
4460
bc10103e
VS
4461#if defined TEST_REGEX && TEST_INTERACTIVE
4462 TestRegExInteractive();
4463#endif // defined TEST_REGEX && TEST_INTERACTIVE
07a56e45 4464
6dfec4b8 4465#ifdef TEST_REGISTRY
daa2c7d9 4466 TestRegistryRead();
6ba63600 4467 TestRegistryAssociation();
6dfec4b8
VZ
4468#endif // TEST_REGISTRY
4469
2c8e4738 4470#ifdef TEST_SOCKETS
daa2c7d9
VZ
4471 TestSocketServer();
4472 TestSocketClient();
2c8e4738
VZ
4473#endif // TEST_SOCKETS
4474
83141d3a 4475#ifdef TEST_STREAMS
e9d2bb6f 4476 #if TEST_ALL
99a5af7f 4477 TestFileStream();
e9d2bb6f 4478 #endif
99a5af7f 4479 TestMemoryStream();
83141d3a
VZ
4480#endif // TEST_STREAMS
4481
39937656
VZ
4482#ifdef TEST_TEXTSTREAM
4483 TestTextInputStream();
4484#endif // TEST_TEXTSTREAM
4485
8d5eff60
VZ
4486#ifdef TEST_THREADS
4487 int nCPUs = wxThread::GetCPUCount();
456ae26d 4488 wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
8d5eff60
VZ
4489 if ( nCPUs != -1 )
4490 wxThread::SetConcurrency(nCPUs);
4491
5bc1deeb
VZ
4492 TestJoinableThreads();
4493
e9d2bb6f 4494 #if TEST_ALL
8d5eff60 4495 TestJoinableThreads();
5bc1deeb 4496 TestDetachedThreads();
8d5eff60
VZ
4497 TestThreadSuspend();
4498 TestThreadDelete();
c112e100 4499 TestThreadConditions();
7aeebdcd 4500 TestSemaphore();
e9d2bb6f 4501 #endif
8d5eff60
VZ
4502#endif // TEST_THREADS
4503
d31b7b68
VZ
4504#ifdef TEST_TIMER
4505 TestStopWatch();
549b95b3 4506 TestTimer();
d31b7b68
VZ
4507#endif // TEST_TIMER
4508
4509#ifdef TEST_DATETIME
e9d2bb6f 4510 #if TEST_ALL
9d9b7755
VZ
4511 TestTimeStatic();
4512 TestTimeRange();
4513 TestTimeZones();
9d9b7755 4514 TestTimeDST();
f6bcfd97 4515 TestTimeHolidays();
daa2c7d9 4516 TestTimeSpanFormat();
3ca6a5f0 4517 TestTimeMS();
f6bcfd97
BP
4518
4519 TestTimeZoneBug();
e9d2bb6f 4520 #endif
2b5f62a0 4521
e9d2bb6f 4522 #if TEST_INTERACTIVE
b92fd37c 4523 TestDateTimeInteractive();
e9d2bb6f 4524 #endif
d31b7b68 4525#endif // TEST_DATETIME
b76b015e 4526
df5168c4
MB
4527#ifdef TEST_SCOPEGUARD
4528 TestScopeGuard();
4529#endif
4530
eaff0f0d 4531#ifdef TEST_STACKWALKER
60c474a0 4532#if wxUSE_STACKWALKER
eaff0f0d 4533 TestStackWalk(argv[0]);
60c474a0 4534#endif
eaff0f0d
VZ
4535#endif // TEST_STACKWALKER
4536
af33b199
VZ
4537#ifdef TEST_STDPATHS
4538 TestStandardPaths();
4539#endif
4540
551fe3a6 4541#ifdef TEST_USLEEP
456ae26d 4542 wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
551fe3a6
VZ
4543 wxUsleep(3000);
4544#endif // TEST_USLEEP
4545
f6bcfd97 4546#ifdef TEST_VCARD
f6bcfd97
BP
4547 TestVCardRead();
4548 TestVCardWrite();
4549#endif // TEST_VCARD
4550
0e2c5534
VZ
4551#ifdef TEST_VOLUME
4552 TestFSVolume();
4553#endif // TEST_VOLUME
4554
f6bcfd97
BP
4555#ifdef TEST_WCHAR
4556 TestUtf8();
ac511156 4557 TestEncodingConverter();
f6bcfd97
BP
4558#endif // TEST_WCHAR
4559
4560#ifdef TEST_ZIP
daa2c7d9 4561 TestZipStreamRead();
2ca8b884 4562 TestZipFileSystem();
f6bcfd97
BP
4563#endif // TEST_ZIP
4564
5ba95b79
WS
4565#if wxUSE_UNICODE
4566 {
4567 for ( int n = 0; n < argc; n++ )
4568 free(wxArgv[n]);
4569
4570 delete [] wxArgv;
4571 }
4572#endif // wxUSE_UNICODE
4573
e9d2bb6f
DS
4574 wxUnusedVar(argc);
4575 wxUnusedVar(argv);
37667812
VZ
4576 return 0;
4577}