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