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