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