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