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