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