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