projects / wxWidgets.git / blob
? search:


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