projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added tests for wxString::To/FromAscii
[wxWidgets.git] / samples / console / console.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: samples/console/console.cpp
3 // Purpose: a sample console (as opposed to GUI) progam using wxWindows
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 #if wxUSE_GUI
23 #error "This sample can't be compiled in GUI mode."
24 #endif // wxUSE_GUI
25
26 #include <stdio.h>
27
28 #include "wx/string.h"
29 #include "wx/file.h"
30 #include "wx/app.h"
31
32 // without this pragma, the stupid compiler precompiles #defines below so that
33 // changing them doesn't "take place" later!
34 #ifdef __VISUALC__
35 #pragma hdrstop
36 #endif
37
38 // ----------------------------------------------------------------------------
39 // conditional compilation
40 // ----------------------------------------------------------------------------
41
42 /*
43 A note about all these conditional compilation macros: this file is used
44 both as a test suite for various non-GUI wxWindows classes and as a
45 scratchpad for quick tests. So there are two compilation modes: if you
46 define TEST_ALL all tests are run, otherwise you may enable the individual
47 tests individually in the "#else" branch below.
48 */
49
50 // what to test (in alphabetic order)? uncomment the line below to do all tests
51 // #define TEST_ALL
52 #ifdef TEST_ALL
53 #define TEST_ARRAYS
54 #define TEST_CHARSET
55 #define TEST_CMDLINE
56 #define TEST_DATETIME
57 #define TEST_DIR
58 #define TEST_DLLLOADER
59 #define TEST_ENVIRON
60 #define TEST_EXECUTE
61 #define TEST_FILE
62 #define TEST_FILECONF
63 #define TEST_FILENAME
64 #define TEST_FILETIME
65 #define TEST_FTP
66 #define TEST_HASH
67 #define TEST_HASHMAP
68 #define TEST_INFO_FUNCTIONS
69 #define TEST_LIST
70 #define TEST_LOCALE
71 #define TEST_LOG
72 #define TEST_LONGLONG
73 #define TEST_MIME
74 #define TEST_PATHLIST
75 #define TEST_ODBC
76 #define TEST_REGCONF
77 #define TEST_REGEX
78 #define TEST_REGISTRY
79 #define TEST_SNGLINST
80 #define TEST_SOCKETS
81 #define TEST_STREAMS
82 #define TEST_STRINGS
83 #define TEST_THREADS
84 #define TEST_TIMER
85 #define TEST_UNICODE
86 // #define TEST_VCARD -- don't enable this (VZ)
87 #define TEST_VOLUME
88 #define TEST_WCHAR
89 #define TEST_ZIP
90 #define TEST_ZLIB
91
92 #undef TEST_ALL
93 static const bool TEST_ALL = TRUE;
94 #else
95 #define TEST_UNICODE
96
97 static const bool TEST_ALL = FALSE;
98 #endif
99
100 // some tests are interactive, define this to run them
101 #ifdef TEST_INTERACTIVE
102 #undef TEST_INTERACTIVE
103
104 static const bool TEST_INTERACTIVE = TRUE;
105 #else
106 static const bool TEST_INTERACTIVE = FALSE;
107 #endif
108
109 // ----------------------------------------------------------------------------
110 // test class for container objects
111 // ----------------------------------------------------------------------------
112
113 #if defined(TEST_ARRAYS) || defined(TEST_LIST)
114
115 class Bar // Foo is already taken in the hash test
116 {
117 public:
118 Bar(const wxString& name) : m_name(name) { ms_bars++; }
119 Bar(const Bar& bar) : m_name(bar.m_name) { ms_bars++; }
120 ~Bar() { ms_bars--; }
121
122 static size_t GetNumber() { return ms_bars; }
123
124 const char *GetName() const { return m_name; }
125
126 private:
127 wxString m_name;
128
129 static size_t ms_bars;
130 };
131
132 size_t Bar::ms_bars = 0;
133
134 #endif // defined(TEST_ARRAYS) || defined(TEST_LIST)
135
136 // ============================================================================
137 // implementation
138 // ============================================================================
139
140 // ----------------------------------------------------------------------------
141 // helper functions
142 // ----------------------------------------------------------------------------
143
144 #if defined(TEST_STRINGS) || defined(TEST_SOCKETS)
145
146 // replace TABs with \t and CRs with \n
147 static wxString MakePrintable(const wxChar *s)
148 {
149 wxString str(s);
150 (void)str.Replace(_T("\t"), _T("\\t"));
151 (void)str.Replace(_T("\n"), _T("\\n"));
152 (void)str.Replace(_T("\r"), _T("\\r"));
153
154 return str;
155 }
156
157 #endif // MakePrintable() is used
158
159 // ----------------------------------------------------------------------------
160 // wxFontMapper::CharsetToEncoding
161 // ----------------------------------------------------------------------------
162
163 #ifdef TEST_CHARSET
164
165 #include "wx/fontmap.h"
166
167 static void TestCharset()
168 {
169 static const wxChar *charsets[] =
170 {
171 // some vali charsets
172 _T("us-ascii "),
173 _T("iso8859-1 "),
174 _T("iso-8859-12 "),
175 _T("koi8-r "),
176 _T("utf-7 "),
177 _T("cp1250 "),
178 _T("windows-1252"),
179
180 // and now some bogus ones
181 _T(" "),
182 _T("cp1249 "),
183 _T("iso--8859-1 "),
184 _T("iso-8859-19 "),
185 };
186
187 for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
188 {
189 wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charsets[n]);
190 wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
191 charsets[n],
192 wxFontMapper::Get()->GetEncodingName(enc).c_str(),
193 wxFontMapper::Get()->GetEncodingDescription(enc).c_str());
194 }
195 }
196
197 #endif // TEST_CHARSET
198
199 // ----------------------------------------------------------------------------
200 // wxCmdLineParser
201 // ----------------------------------------------------------------------------
202
203 #ifdef TEST_CMDLINE
204
205 #include "wx/cmdline.h"
206 #include "wx/datetime.h"
207
208 #if wxUSE_CMDLINE_PARSER
209
210 static void ShowCmdLine(const wxCmdLineParser& parser)
211 {
212 wxString s = "Input files: ";
213
214 size_t count = parser.GetParamCount();
215 for ( size_t param = 0; param < count; param++ )
216 {
217 s << parser.GetParam(param) << ' ';
218 }
219
220 s << '\n'
221 << "Verbose:\t" << (parser.Found("v") ? "yes" : "no") << '\n'
222 << "Quiet:\t" << (parser.Found("q") ? "yes" : "no") << '\n';
223
224 wxString strVal;
225 long lVal;
226 wxDateTime dt;
227 if ( parser.Found("o", &strVal) )
228 s << "Output file:\t" << strVal << '\n';
229 if ( parser.Found("i", &strVal) )
230 s << "Input dir:\t" << strVal << '\n';
231 if ( parser.Found("s", &lVal) )
232 s << "Size:\t" << lVal << '\n';
233 if ( parser.Found("d", &dt) )
234 s << "Date:\t" << dt.FormatISODate() << '\n';
235 if ( parser.Found("project_name", &strVal) )
236 s << "Project:\t" << strVal << '\n';
237
238 wxLogMessage(s);
239 }
240
241 #endif // wxUSE_CMDLINE_PARSER
242
243 static void TestCmdLineConvert()
244 {
245 static const char *cmdlines[] =
246 {
247 "arg1 arg2",
248 "-a \"-bstring 1\" -c\"string 2\" \"string 3\"",
249 "literal \\\" and \"\"",
250 };
251
252 for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
253 {
254 const char *cmdline = cmdlines[n];
255 printf("Parsing: %s\n", cmdline);
256 wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
257
258 size_t count = args.GetCount();
259 printf("\targc = %u\n", count);
260 for ( size_t arg = 0; arg < count; arg++ )
261 {
262 printf("\targv[%u] = %s\n", arg, args[arg].c_str());
263 }
264 }
265 }
266
267 #endif // TEST_CMDLINE
268
269 // ----------------------------------------------------------------------------
270 // wxDir
271 // ----------------------------------------------------------------------------
272
273 #ifdef TEST_DIR
274
275 #include "wx/dir.h"
276
277 #ifdef __UNIX__
278 static const wxChar *ROOTDIR = _T("/");
279 static const wxChar *TESTDIR = _T("/usr");
280 #elif defined(__WXMSW__)
281 static const wxChar *ROOTDIR = _T("c:\\");
282 static const wxChar *TESTDIR = _T("d:\\");
283 #else
284 #error "don't know where the root directory is"
285 #endif
286
287 static void TestDirEnumHelper(wxDir& dir,
288 int flags = wxDIR_DEFAULT,
289 const wxString& filespec = wxEmptyString)
290 {
291 wxString filename;
292
293 if ( !dir.IsOpened() )
294 return;
295
296 bool cont = dir.GetFirst(&filename, filespec, flags);
297 while ( cont )
298 {
299 printf("\t%s\n", filename.c_str());
300
301 cont = dir.GetNext(&filename);
302 }
303
304 puts("");
305 }
306
307 static void TestDirEnum()
308 {
309 puts("*** Testing wxDir::GetFirst/GetNext ***");
310
311 wxString cwd = wxGetCwd();
312 if ( !wxDir::Exists(cwd) )
313 {
314 printf("ERROR: current directory '%s' doesn't exist?\n", cwd.c_str());
315 return;
316 }
317
318 wxDir dir("s:/tmp/foo");
319 if ( !dir.IsOpened() )
320 {
321 printf("ERROR: failed to open current directory '%s'.\n", cwd.c_str());
322 return;
323 }
324
325 puts("Enumerating everything in current directory:");
326 TestDirEnumHelper(dir);
327
328 puts("Enumerating really everything in current directory:");
329 TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
330
331 puts("Enumerating object files in current directory:");
332 TestDirEnumHelper(dir, wxDIR_DEFAULT, "*.o");
333
334 puts("Enumerating directories in current directory:");
335 TestDirEnumHelper(dir, wxDIR_DIRS);
336
337 puts("Enumerating files in current directory:");
338 TestDirEnumHelper(dir, wxDIR_FILES);
339
340 puts("Enumerating files including hidden in current directory:");
341 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
342
343 dir.Open(ROOTDIR);
344
345 puts("Enumerating everything in root directory:");
346 TestDirEnumHelper(dir, wxDIR_DEFAULT);
347
348 puts("Enumerating directories in root directory:");
349 TestDirEnumHelper(dir, wxDIR_DIRS);
350
351 puts("Enumerating files in root directory:");
352 TestDirEnumHelper(dir, wxDIR_FILES);
353
354 puts("Enumerating files including hidden in root directory:");
355 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
356
357 puts("Enumerating files in non existing directory:");
358 wxDir dirNo("nosuchdir");
359 TestDirEnumHelper(dirNo);
360 }
361
362 class DirPrintTraverser : public wxDirTraverser
363 {
364 public:
365 virtual wxDirTraverseResult OnFile(const wxString& filename)
366 {
367 return wxDIR_CONTINUE;
368 }
369
370 virtual wxDirTraverseResult OnDir(const wxString& dirname)
371 {
372 wxString path, name, ext;
373 wxSplitPath(dirname, &path, &name, &ext);
374
375 if ( !ext.empty() )
376 name << _T('.') << ext;
377
378 wxString indent;
379 for ( const wxChar *p = path.c_str(); *p; p++ )
380 {
381 if ( wxIsPathSeparator(*p) )
382 indent += _T(" ");
383 }
384
385 printf("%s%s\n", indent.c_str(), name.c_str());
386
387 return wxDIR_CONTINUE;
388 }
389 };
390
391 static void TestDirTraverse()
392 {
393 puts("*** Testing wxDir::Traverse() ***");
394
395 // enum all files
396 wxArrayString files;
397 size_t n = wxDir::GetAllFiles(TESTDIR, &files);
398 printf("There are %u files under '%s'\n", n, TESTDIR);
399 if ( n > 1 )
400 {
401 printf("First one is '%s'\n", files[0u].c_str());
402 printf(" last one is '%s'\n", files[n - 1].c_str());
403 }
404
405 // enum again with custom traverser
406 wxDir dir(TESTDIR);
407 DirPrintTraverser traverser;
408 dir.Traverse(traverser, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
409 }
410
411 static void TestDirExists()
412 {
413 wxPuts(_T("*** Testing wxDir::Exists() ***"));
414
415 static const char *dirnames[] =
416 {
417 _T("."),
418 #if defined(__WXMSW__)
419 _T("c:"),
420 _T("c:\\"),
421 _T("\\\\share\\file"),
422 _T("c:\\dos"),
423 _T("c:\\dos\\"),
424 _T("c:\\dos\\\\"),
425 _T("c:\\autoexec.bat"),
426 #elif defined(__UNIX__)
427 _T("/"),
428 _T("//"),
429 _T("/usr/bin"),
430 _T("/usr//bin"),
431 _T("/usr///bin"),
432 #endif
433 };
434
435 for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
436 {
437 printf(_T("%-40s: %s\n"),
438 dirnames[n],
439 wxDir::Exists(dirnames[n]) ? _T("exists") : _T("doesn't exist"));
440 }
441 }
442
443 #endif // TEST_DIR
444
445 // ----------------------------------------------------------------------------
446 // wxDllLoader
447 // ----------------------------------------------------------------------------
448
449 #ifdef TEST_DLLLOADER
450
451 #include "wx/dynlib.h"
452
453 static void TestDllLoad()
454 {
455 #if defined(__WXMSW__)
456 static const wxChar *LIB_NAME = _T("kernel32.dll");
457 static const wxChar *FUNC_NAME = _T("lstrlenA");
458 #elif defined(__UNIX__)
459 // weird: using just libc.so does *not* work!
460 static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
461 static const wxChar *FUNC_NAME = _T("strlen");
462 #else
463 #error "don't know how to test wxDllLoader on this platform"
464 #endif
465
466 puts("*** testing wxDllLoader ***\n");
467
468 wxDllType dllHandle = wxDllLoader::LoadLibrary(LIB_NAME);
469 if ( !dllHandle )
470 {
471 wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
472 }
473 else
474 {
475 typedef int (*strlenType)(const char *);
476 strlenType pfnStrlen = (strlenType)wxDllLoader::GetSymbol(dllHandle, FUNC_NAME);
477 if ( !pfnStrlen )
478 {
479 wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
480 FUNC_NAME, LIB_NAME);
481 }
482 else
483 {
484 if ( pfnStrlen("foo") != 3 )
485 {
486 wxPrintf(_T("ERROR: loaded function is not strlen()!\n"));
487 }
488 else
489 {
490 puts("... ok");
491 }
492 }
493
494 wxDllLoader::UnloadLibrary(dllHandle);
495 }
496 }
497
498 #endif // TEST_DLLLOADER
499
500 // ----------------------------------------------------------------------------
501 // wxGet/SetEnv
502 // ----------------------------------------------------------------------------
503
504 #ifdef TEST_ENVIRON
505
506 #include "wx/utils.h"
507
508 static wxString MyGetEnv(const wxString& var)
509 {
510 wxString val;
511 if ( !wxGetEnv(var, &val) )
512 val = _T("<empty>");
513 else
514 val = wxString(_T('\'')) + val + _T('\'');
515
516 return val;
517 }
518
519 static void TestEnvironment()
520 {
521 const wxChar *var = _T("wxTestVar");
522
523 puts("*** testing environment access functions ***");
524
525 printf("Initially getenv(%s) = %s\n", var, MyGetEnv(var).c_str());
526 wxSetEnv(var, _T("value for wxTestVar"));
527 printf("After wxSetEnv: getenv(%s) = %s\n", var, MyGetEnv(var).c_str());
528 wxSetEnv(var, _T("another value"));
529 printf("After 2nd wxSetEnv: getenv(%s) = %s\n", var, MyGetEnv(var).c_str());
530 wxUnsetEnv(var);
531 printf("After wxUnsetEnv: getenv(%s) = %s\n", var, MyGetEnv(var).c_str());
532 printf("PATH = %s\n", MyGetEnv(_T("PATH")).c_str());
533 }
534
535 #endif // TEST_ENVIRON
536
537 // ----------------------------------------------------------------------------
538 // wxExecute
539 // ----------------------------------------------------------------------------
540
541 #ifdef TEST_EXECUTE
542
543 #include "wx/utils.h"
544
545 static void TestExecute()
546 {
547 puts("*** testing wxExecute ***");
548
549 #ifdef __UNIX__
550 #define COMMAND "cat -n ../../Makefile" // "echo hi"
551 #define SHELL_COMMAND "echo hi from shell"
552 #define REDIRECT_COMMAND COMMAND // "date"
553 #elif defined(__WXMSW__)
554 #define COMMAND "command.com -c 'echo hi'"
555 #define SHELL_COMMAND "echo hi"
556 #define REDIRECT_COMMAND COMMAND
557 #else
558 #error "no command to exec"
559 #endif // OS
560
561 printf("Testing wxShell: ");
562 fflush(stdout);
563 if ( wxShell(SHELL_COMMAND) )
564 puts("Ok.");
565 else
566 puts("ERROR.");
567
568 printf("Testing wxExecute: ");
569 fflush(stdout);
570 if ( wxExecute(COMMAND, TRUE /* sync */) == 0 )
571 puts("Ok.");
572 else
573 puts("ERROR.");
574
575 #if 0 // no, it doesn't work (yet?)
576 printf("Testing async wxExecute: ");
577 fflush(stdout);
578 if ( wxExecute(COMMAND) != 0 )
579 puts("Ok (command launched).");
580 else
581 puts("ERROR.");
582 #endif // 0
583
584 printf("Testing wxExecute with redirection:\n");
585 wxArrayString output;
586 if ( wxExecute(REDIRECT_COMMAND, output) != 0 )
587 {
588 puts("ERROR.");
589 }
590 else
591 {
592 size_t count = output.GetCount();
593 for ( size_t n = 0; n < count; n++ )
594 {
595 printf("\t%s\n", output[n].c_str());
596 }
597
598 puts("Ok.");
599 }
600 }
601
602 #endif // TEST_EXECUTE
603
604 // ----------------------------------------------------------------------------
605 // file
606 // ----------------------------------------------------------------------------
607
608 #ifdef TEST_FILE
609
610 #include "wx/file.h"
611 #include "wx/ffile.h"
612 #include "wx/textfile.h"
613
614 static void TestFileRead()
615 {
616 puts("*** wxFile read test ***");
617
618 wxFile file(_T("testdata.fc"));
619 if ( file.IsOpened() )
620 {
621 printf("File length: %lu\n", file.Length());
622
623 puts("File dump:\n----------");
624
625 static const off_t len = 1024;
626 char buf[len];
627 for ( ;; )
628 {
629 off_t nRead = file.Read(buf, len);
630 if ( nRead == wxInvalidOffset )
631 {
632 printf("Failed to read the file.");
633 break;
634 }
635
636 fwrite(buf, nRead, 1, stdout);
637
638 if ( nRead < len )
639 break;
640 }
641
642 puts("----------");
643 }
644 else
645 {
646 printf("ERROR: can't open test file.\n");
647 }
648
649 puts("");
650 }
651
652 static void TestTextFileRead()
653 {
654 puts("*** wxTextFile read test ***");
655
656 wxTextFile file(_T("testdata.fc"));
657 if ( file.Open() )
658 {
659 printf("Number of lines: %u\n", file.GetLineCount());
660 printf("Last line: '%s'\n", file.GetLastLine().c_str());
661
662 wxString s;
663
664 puts("\nDumping the entire file:");
665 for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
666 {
667 printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
668 }
669 printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
670
671 puts("\nAnd now backwards:");
672 for ( s = file.GetLastLine();
673 file.GetCurrentLine() != 0;
674 s = file.GetPrevLine() )
675 {
676 printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
677 }
678 printf("%6u: %s\n", file.GetCurrentLine() + 1, s.c_str());
679 }
680 else
681 {
682 printf("ERROR: can't open '%s'\n", file.GetName());
683 }
684
685 puts("");
686 }
687
688 static void TestFileCopy()
689 {
690 puts("*** Testing wxCopyFile ***");
691
692 static const wxChar *filename1 = _T("testdata.fc");
693 static const wxChar *filename2 = _T("test2");
694 if ( !wxCopyFile(filename1, filename2) )
695 {
696 puts("ERROR: failed to copy file");
697 }
698 else
699 {
700 wxFFile f1(filename1, "rb"),
701 f2(filename2, "rb");
702
703 if ( !f1.IsOpened() || !f2.IsOpened() )
704 {
705 puts("ERROR: failed to open file(s)");
706 }
707 else
708 {
709 wxString s1, s2;
710 if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
711 {
712 puts("ERROR: failed to read file(s)");
713 }
714 else
715 {
716 if ( (s1.length() != s2.length()) ||
717 (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
718 {
719 puts("ERROR: copy error!");
720 }
721 else
722 {
723 puts("File was copied ok.");
724 }
725 }
726 }
727 }
728
729 if ( !wxRemoveFile(filename2) )
730 {
731 puts("ERROR: failed to remove the file");
732 }
733
734 puts("");
735 }
736
737 #endif // TEST_FILE
738
739 // ----------------------------------------------------------------------------
740 // wxFileConfig
741 // ----------------------------------------------------------------------------
742
743 #ifdef TEST_FILECONF
744
745 #include "wx/confbase.h"
746 #include "wx/fileconf.h"
747
748 static const struct FileConfTestData
749 {
750 const wxChar *name; // value name
751 const wxChar *value; // the value from the file
752 } fcTestData[] =
753 {
754 { _T("value1"), _T("one") },
755 { _T("value2"), _T("two") },
756 { _T("novalue"), _T("default") },
757 };
758
759 static void TestFileConfRead()
760 {
761 puts("*** testing wxFileConfig loading/reading ***");
762
763 wxFileConfig fileconf(_T("test"), wxEmptyString,
764 _T("testdata.fc"), wxEmptyString,
765 wxCONFIG_USE_RELATIVE_PATH);
766
767 // test simple reading
768 puts("\nReading config file:");
769 wxString defValue(_T("default")), value;
770 for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
771 {
772 const FileConfTestData& data = fcTestData[n];
773 value = fileconf.Read(data.name, defValue);
774 printf("\t%s = %s ", data.name, value.c_str());
775 if ( value == data.value )
776 {
777 puts("(ok)");
778 }
779 else
780 {
781 printf("(ERROR: should be %s)\n", data.value);
782 }
783 }
784
785 // test enumerating the entries
786 puts("\nEnumerating all root entries:");
787 long dummy;
788 wxString name;
789 bool cont = fileconf.GetFirstEntry(name, dummy);
790 while ( cont )
791 {
792 printf("\t%s = %s\n",
793 name.c_str(),
794 fileconf.Read(name.c_str(), _T("ERROR")).c_str());
795
796 cont = fileconf.GetNextEntry(name, dummy);
797 }
798 }
799
800 #endif // TEST_FILECONF
801
802 // ----------------------------------------------------------------------------
803 // wxFileName
804 // ----------------------------------------------------------------------------
805
806 #ifdef TEST_FILENAME
807
808 #include "wx/filename.h"
809
810 static void DumpFileName(const wxFileName& fn)
811 {
812 wxString full = fn.GetFullPath();
813
814 wxString vol, path, name, ext;
815 wxFileName::SplitPath(full, &vol, &path, &name, &ext);
816
817 wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
818 full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
819
820 wxFileName::SplitPath(full, &path, &name, &ext);
821 wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
822 path.c_str(), name.c_str(), ext.c_str());
823
824 wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
825 wxPrintf(_T("with volume: \t'%s'\n"),
826 fn.GetPath(wxPATH_GET_VOLUME).c_str());
827 wxPrintf(_T("with separator:\t'%s'\n"),
828 fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
829 wxPrintf(_T("with both: \t'%s'\n"),
830 fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
831
832 wxPuts(_T("The directories in the path are:"));
833 wxArrayString dirs = fn.GetDirs();
834 size_t count = dirs.GetCount();
835 for ( size_t n = 0; n < count; n++ )
836 {
837 wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
838 }
839 }
840
841 static struct FileNameInfo
842 {
843 const wxChar *fullname;
844 const wxChar *volume;
845 const wxChar *path;
846 const wxChar *name;
847 const wxChar *ext;
848 bool isAbsolute;
849 wxPathFormat format;
850 } filenames[] =
851 {
852 // Unix file names
853 { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), TRUE, wxPATH_UNIX },
854 { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), TRUE, wxPATH_UNIX },
855 { _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), TRUE, wxPATH_UNIX },
856 { _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), FALSE, wxPATH_UNIX },
857 { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
858 { _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), TRUE, wxPATH_UNIX },
859 { _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), TRUE, wxPATH_UNIX },
860 { _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
861 { _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), TRUE, wxPATH_UNIX },
862
863 // Windows file names
864 { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
865 { _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
866 { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
867 { _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
868 { _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), TRUE, wxPATH_DOS },
869 { _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
870 { _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
871
872 // wxFileName support for Mac file names is broken currently
873 #if 0
874 // Mac file names
875 { _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
876 { _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
877 { _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), TRUE, wxPATH_MAC },
878 { _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), FALSE, wxPATH_MAC },
879 { _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
880 { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
881 #endif // 0
882
883 // VMS file names
884 { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE, wxPATH_VMS },
885 { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), FALSE, wxPATH_VMS },
886 };
887
888 static void TestFileNameConstruction()
889 {
890 puts("*** testing wxFileName construction ***");
891
892 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
893 {
894 const FileNameInfo& fni = filenames[n];
895
896 wxFileName fn(fni.fullname, fni.format);
897
898 wxString fullname = fn.GetFullPath(fni.format);
899 if ( fullname != fni.fullname )
900 {
901 printf("ERROR: fullname should be '%s'\n", fni.fullname);
902 }
903
904 bool isAbsolute = fn.IsAbsolute(fni.format);
905 printf("'%s' is %s (%s)\n\t",
906 fullname.c_str(),
907 isAbsolute ? "absolute" : "relative",
908 isAbsolute == fni.isAbsolute ? "ok" : "ERROR");
909
910 if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), fni.format) )
911 {
912 puts("ERROR (couldn't be normalized)");
913 }
914 else
915 {
916 printf("normalized: '%s'\n", fn.GetFullPath(fni.format).c_str());
917 }
918 }
919
920 puts("");
921 }
922
923 static void TestFileNameSplit()
924 {
925 puts("*** testing wxFileName splitting ***");
926
927 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
928 {
929 const FileNameInfo& fni = filenames[n];
930 wxString volume, path, name, ext;
931 wxFileName::SplitPath(fni.fullname,
932 &volume, &path, &name, &ext, fni.format);
933
934 printf("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'",
935 fni.fullname,
936 volume.c_str(), path.c_str(), name.c_str(), ext.c_str());
937
938 if ( volume != fni.volume )
939 printf(" (ERROR: volume = '%s')", fni.volume);
940 if ( path != fni.path )
941 printf(" (ERROR: path = '%s')", fni.path);
942 if ( name != fni.name )
943 printf(" (ERROR: name = '%s')", fni.name);
944 if ( ext != fni.ext )
945 printf(" (ERROR: ext = '%s')", fni.ext);
946
947 puts("");
948 }
949 }
950
951 static void TestFileNameTemp()
952 {
953 puts("*** testing wxFileName temp file creation ***");
954
955 static const char *tmpprefixes[] =
956 {
957 "",
958 "foo",
959 "..",
960 "../bar",
961 #ifdef __UNIX__
962 "/tmp/foo",
963 "/tmp/foo/bar", // this one must be an error
964 #endif // __UNIX__
965 };
966
967 for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
968 {
969 wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
970 if ( path.empty() )
971 {
972 // "error" is not in upper case because it may be ok
973 printf("Prefix '%s'\t-> error\n", tmpprefixes[n]);
974 }
975 else
976 {
977 printf("Prefix '%s'\t-> temp file '%s'\n",
978 tmpprefixes[n], path.c_str());
979
980 if ( !wxRemoveFile(path) )
981 {
982 wxLogWarning("Failed to remove temp file '%s'", path.c_str());
983 }
984 }
985 }
986 }
987
988 static void TestFileNameMakeRelative()
989 {
990 puts("*** testing wxFileName::MakeRelativeTo() ***");
991
992 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
993 {
994 const FileNameInfo& fni = filenames[n];
995
996 wxFileName fn(fni.fullname, fni.format);
997
998 // choose the base dir of the same format
999 wxString base;
1000 switch ( fni.format )
1001 {
1002 case wxPATH_UNIX:
1003 base = "/usr/bin/";
1004 break;
1005
1006 case wxPATH_DOS:
1007 base = "c:\\";
1008 break;
1009
1010 case wxPATH_MAC:
1011 case wxPATH_VMS:
1012 // TODO: I don't know how this is supposed to work there
1013 continue;
1014
1015 case wxPATH_NATIVE: // make gcc happy
1016 default:
1017 wxFAIL_MSG( "unexpected path format" );
1018 }
1019
1020 printf("'%s' relative to '%s': ",
1021 fn.GetFullPath(fni.format).c_str(), base.c_str());
1022
1023 if ( !fn.MakeRelativeTo(base, fni.format) )
1024 {
1025 puts("unchanged");
1026 }
1027 else
1028 {
1029 printf("'%s'\n", fn.GetFullPath(fni.format).c_str());
1030 }
1031 }
1032 }
1033
1034 static void TestFileNameComparison()
1035 {
1036 // TODO!
1037 }
1038
1039 static void TestFileNameOperations()
1040 {
1041 // TODO!
1042 }
1043
1044 static void TestFileNameCwd()
1045 {
1046 // TODO!
1047 }
1048
1049 #endif // TEST_FILENAME
1050
1051 // ----------------------------------------------------------------------------
1052 // wxFileName time functions
1053 // ----------------------------------------------------------------------------
1054
1055 #ifdef TEST_FILETIME
1056
1057 #include <wx/filename.h>
1058 #include <wx/datetime.h>
1059
1060 static void TestFileGetTimes()
1061 {
1062 wxFileName fn(_T("testdata.fc"));
1063
1064 wxDateTime dtAccess, dtMod, dtCreate;
1065 if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
1066 {
1067 wxPrintf(_T("ERROR: GetTimes() failed.\n"));
1068 }
1069 else
1070 {
1071 static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
1072
1073 wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
1074 wxPrintf(_T("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
1075 wxPrintf(_T("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
1076 wxPrintf(_T("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
1077 }
1078 }
1079
1080 static void TestFileSetTimes()
1081 {
1082 wxFileName fn(_T("testdata.fc"));
1083
1084 if ( !fn.Touch() )
1085 {
1086 wxPrintf(_T("ERROR: Touch() failed.\n"));
1087 }
1088 }
1089
1090 #endif // TEST_FILETIME
1091
1092 // ----------------------------------------------------------------------------
1093 // wxHashTable
1094 // ----------------------------------------------------------------------------
1095
1096 #ifdef TEST_HASH
1097
1098 #include "wx/hash.h"
1099
1100 struct Foo
1101 {
1102 Foo(int n_) { n = n_; count++; }
1103 ~Foo() { count--; }
1104
1105 int n;
1106
1107 static size_t count;
1108 };
1109
1110 size_t Foo::count = 0;
1111
1112 WX_DECLARE_LIST(Foo, wxListFoos);
1113 WX_DECLARE_HASH(Foo, wxListFoos, wxHashFoos);
1114
1115 #include "wx/listimpl.cpp"
1116
1117 WX_DEFINE_LIST(wxListFoos);
1118
1119 static void TestHash()
1120 {
1121 puts("*** Testing wxHashTable ***\n");
1122
1123 {
1124 wxHashFoos hash;
1125 hash.DeleteContents(TRUE);
1126
1127 printf("Hash created: %u foos in hash, %u foos totally\n",
1128 hash.GetCount(), Foo::count);
1129
1130 static const int hashTestData[] =
1131 {
1132 0, 1, 17, -2, 2, 4, -4, 345, 3, 3, 2, 1,
1133 };
1134
1135 size_t n;
1136 for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
1137 {
1138 hash.Put(hashTestData[n], n, new Foo(n));
1139 }
1140
1141 printf("Hash filled: %u foos in hash, %u foos totally\n",
1142 hash.GetCount(), Foo::count);
1143
1144 puts("Hash access test:");
1145 for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
1146 {
1147 printf("\tGetting element with key %d, value %d: ",
1148 hashTestData[n], n);
1149 Foo *foo = hash.Get(hashTestData[n], n);
1150 if ( !foo )
1151 {
1152 printf("ERROR, not found.\n");
1153 }
1154 else
1155 {
1156 printf("%d (%s)\n", foo->n,
1157 (size_t)foo->n == n ? "ok" : "ERROR");
1158 }
1159 }
1160
1161 printf("\nTrying to get an element not in hash: ");
1162
1163 if ( hash.Get(1234) || hash.Get(1, 0) )
1164 {
1165 puts("ERROR: found!");
1166 }
1167 else
1168 {
1169 puts("ok (not found)");
1170 }
1171 }
1172
1173 printf("Hash destroyed: %u foos left\n", Foo::count);
1174 }
1175
1176 #endif // TEST_HASH
1177
1178 // ----------------------------------------------------------------------------
1179 // wxHashMap
1180 // ----------------------------------------------------------------------------
1181
1182 #ifdef TEST_HASHMAP
1183
1184 #include "wx/hashmap.h"
1185
1186 // test compilation of basic map types
1187 WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash, wxPointerEqual, myPtrHashMap );
1188 WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
1189 WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
1190 myUnsignedHashMap );
1191 WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
1192 myTestHashMap1 );
1193 WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
1194 myTestHashMap2 );
1195 WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
1196 myTestHashMap3 );
1197 WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
1198 myTestHashMap4 );
1199
1200 // same as:
1201 // WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
1202 // myStringHashMap );
1203 WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
1204
1205 typedef myStringHashMap::iterator Itor;
1206
1207 static void TestHashMap()
1208 {
1209 puts("*** Testing wxHashMap ***\n");
1210 myStringHashMap sh(0); // as small as possible
1211 wxString buf;
1212 size_t i;
1213 const size_t count = 10000;
1214
1215 // init with some data
1216 for( i = 0; i < count; ++i )
1217 {
1218 buf.Printf(wxT("%d"), i );
1219 sh[buf] = wxT("A") + buf + wxT("C");
1220 }
1221
1222 // test that insertion worked
1223 if( sh.size() != count )
1224 {
1225 printf("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n", sh.size(), count);
1226 }
1227
1228 for( i = 0; i < count; ++i )
1229 {
1230 buf.Printf(wxT("%d"), i );
1231 if( sh[buf] != wxT("A") + buf + wxT("C") )
1232 {
1233 printf("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n");
1234 return;
1235 }
1236 }
1237
1238 // check that iterators work
1239 Itor it;
1240 for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1241 {
1242 if( i == count )
1243 {
1244 printf("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n");
1245 return;
1246 }
1247
1248 if( it->second != sh[it->first] )
1249 {
1250 printf("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n");
1251 return;
1252 }
1253 }
1254
1255 if( sh.size() != i )
1256 {
1257 printf("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n", i, count);
1258 }
1259
1260 // test copy ctor, assignment operator
1261 myStringHashMap h1( sh ), h2( 0 );
1262 h2 = sh;
1263
1264 for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1265 {
1266 if( h1[it->first] != it->second )
1267 {
1268 printf("*** ERROR: COPY CTOR BROKEN %s ***\n", it->first.c_str());
1269 }
1270
1271 if( h2[it->first] != it->second )
1272 {
1273 printf("*** ERROR: OPERATOR= BROKEN %s ***\n", it->first.c_str());
1274 }
1275 }
1276
1277 // other tests
1278 for( i = 0; i < count; ++i )
1279 {
1280 buf.Printf(wxT("%d"), i );
1281 size_t sz = sh.size();
1282
1283 // test find() and erase(it)
1284 if( i < 100 )
1285 {
1286 it = sh.find( buf );
1287 if( it != sh.end() )
1288 {
1289 sh.erase( it );
1290
1291 if( sh.find( buf ) != sh.end() )
1292 {
1293 printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i);
1294 }
1295 }
1296 else
1297 printf("*** ERROR: CANT FIND ELEMENT %u ***\n", i);
1298 }
1299 else
1300 // test erase(key)
1301 {
1302 size_t c = sh.erase( buf );
1303 if( c != 1 )
1304 printf("*** ERROR: SHOULD RETURN 1 ***\n");
1305
1306 if( sh.find( buf ) != sh.end() )
1307 {
1308 printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i);
1309 }
1310 }
1311
1312 // count should decrease
1313 if( sh.size() != sz - 1 )
1314 {
1315 printf("*** ERROR: COUNT DID NOT DECREASE ***\n");
1316 }
1317 }
1318
1319 printf("*** Finished testing wxHashMap ***\n");
1320 }
1321
1322 #endif // TEST_HASHMAP
1323
1324 // ----------------------------------------------------------------------------
1325 // wxList
1326 // ----------------------------------------------------------------------------
1327
1328 #ifdef TEST_LIST
1329
1330 #include "wx/list.h"
1331
1332 WX_DECLARE_LIST(Bar, wxListBars);
1333 #include "wx/listimpl.cpp"
1334 WX_DEFINE_LIST(wxListBars);
1335
1336 static void TestListCtor()
1337 {
1338 puts("*** Testing wxList construction ***\n");
1339
1340 {
1341 wxListBars list1;
1342 list1.Append(new Bar(_T("first")));
1343 list1.Append(new Bar(_T("second")));
1344
1345 printf("After 1st list creation: %u objects in the list, %u objects total.\n",
1346 list1.GetCount(), Bar::GetNumber());
1347
1348 wxListBars list2;
1349 list2 = list1;
1350
1351 printf("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n",
1352 list1.GetCount(), list2.GetCount(), Bar::GetNumber());
1353
1354 list1.DeleteContents(TRUE);
1355 }
1356
1357 printf("After list destruction: %u objects left.\n", Bar::GetNumber());
1358 }
1359
1360 #endif // TEST_LIST
1361
1362 // ----------------------------------------------------------------------------
1363 // wxLocale
1364 // ----------------------------------------------------------------------------
1365
1366 #ifdef TEST_LOCALE
1367
1368 #include "wx/intl.h"
1369 #include "wx/utils.h" // for wxSetEnv
1370
1371 static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
1372
1373 // find the name of the language from its value
1374 static const char *GetLangName(int lang)
1375 {
1376 static const char *languageNames[] =
1377 {
1378 "DEFAULT",
1379 "UNKNOWN",
1380 "ABKHAZIAN",
1381 "AFAR",
1382 "AFRIKAANS",
1383 "ALBANIAN",
1384 "AMHARIC",
1385 "ARABIC",
1386 "ARABIC_ALGERIA",
1387 "ARABIC_BAHRAIN",
1388 "ARABIC_EGYPT",
1389 "ARABIC_IRAQ",
1390 "ARABIC_JORDAN",
1391 "ARABIC_KUWAIT",
1392 "ARABIC_LEBANON",
1393 "ARABIC_LIBYA",
1394 "ARABIC_MOROCCO",
1395 "ARABIC_OMAN",
1396 "ARABIC_QATAR",
1397 "ARABIC_SAUDI_ARABIA",
1398 "ARABIC_SUDAN",
1399 "ARABIC_SYRIA",
1400 "ARABIC_TUNISIA",
1401 "ARABIC_UAE",
1402 "ARABIC_YEMEN",
1403 "ARMENIAN",
1404 "ASSAMESE",
1405 "AYMARA",
1406 "AZERI",
1407 "AZERI_CYRILLIC",
1408 "AZERI_LATIN",
1409 "BASHKIR",
1410 "BASQUE",
1411 "BELARUSIAN",
1412 "BENGALI",
1413 "BHUTANI",
1414 "BIHARI",
1415 "BISLAMA",
1416 "BRETON",
1417 "BULGARIAN",
1418 "BURMESE",
1419 "CAMBODIAN",
1420 "CATALAN",
1421 "CHINESE",
1422 "CHINESE_SIMPLIFIED",
1423 "CHINESE_TRADITIONAL",
1424 "CHINESE_HONGKONG",
1425 "CHINESE_MACAU",
1426 "CHINESE_SINGAPORE",
1427 "CHINESE_TAIWAN",
1428 "CORSICAN",
1429 "CROATIAN",
1430 "CZECH",
1431 "DANISH",
1432 "DUTCH",
1433 "DUTCH_BELGIAN",
1434 "ENGLISH",
1435 "ENGLISH_UK",
1436 "ENGLISH_US",
1437 "ENGLISH_AUSTRALIA",
1438 "ENGLISH_BELIZE",
1439 "ENGLISH_BOTSWANA",
1440 "ENGLISH_CANADA",
1441 "ENGLISH_CARIBBEAN",
1442 "ENGLISH_DENMARK",
1443 "ENGLISH_EIRE",
1444 "ENGLISH_JAMAICA",
1445 "ENGLISH_NEW_ZEALAND",
1446 "ENGLISH_PHILIPPINES",
1447 "ENGLISH_SOUTH_AFRICA",
1448 "ENGLISH_TRINIDAD",
1449 "ENGLISH_ZIMBABWE",
1450 "ESPERANTO",
1451 "ESTONIAN",
1452 "FAEROESE",
1453 "FARSI",
1454 "FIJI",
1455 "FINNISH",
1456 "FRENCH",
1457 "FRENCH_BELGIAN",
1458 "FRENCH_CANADIAN",
1459 "FRENCH_LUXEMBOURG",
1460 "FRENCH_MONACO",
1461 "FRENCH_SWISS",
1462 "FRISIAN",
1463 "GALICIAN",
1464 "GEORGIAN",
1465 "GERMAN",
1466 "GERMAN_AUSTRIAN",
1467 "GERMAN_BELGIUM",
1468 "GERMAN_LIECHTENSTEIN",
1469 "GERMAN_LUXEMBOURG",
1470 "GERMAN_SWISS",
1471 "GREEK",
1472 "GREENLANDIC",
1473 "GUARANI",
1474 "GUJARATI",
1475 "HAUSA",
1476 "HEBREW",
1477 "HINDI",
1478 "HUNGARIAN",
1479 "ICELANDIC",
1480 "INDONESIAN",
1481 "INTERLINGUA",
1482 "INTERLINGUE",
1483 "INUKTITUT",
1484 "INUPIAK",
1485 "IRISH",
1486 "ITALIAN",
1487 "ITALIAN_SWISS",
1488 "JAPANESE",
1489 "JAVANESE",
1490 "KANNADA",
1491 "KASHMIRI",
1492 "KASHMIRI_INDIA",
1493 "KAZAKH",
1494 "KERNEWEK",
1495 "KINYARWANDA",
1496 "KIRGHIZ",
1497 "KIRUNDI",
1498 "KONKANI",
1499 "KOREAN",
1500 "KURDISH",
1501 "LAOTHIAN",
1502 "LATIN",
1503 "LATVIAN",
1504 "LINGALA",
1505 "LITHUANIAN",
1506 "MACEDONIAN",
1507 "MALAGASY",
1508 "MALAY",
1509 "MALAYALAM",
1510 "MALAY_BRUNEI_DARUSSALAM",
1511 "MALAY_MALAYSIA",
1512 "MALTESE",
1513 "MANIPURI",
1514 "MAORI",
1515 "MARATHI",
1516 "MOLDAVIAN",
1517 "MONGOLIAN",
1518 "NAURU",
1519 "NEPALI",
1520 "NEPALI_INDIA",
1521 "NORWEGIAN_BOKMAL",
1522 "NORWEGIAN_NYNORSK",
1523 "OCCITAN",
1524 "ORIYA",
1525 "OROMO",
1526 "PASHTO",
1527 "POLISH",
1528 "PORTUGUESE",
1529 "PORTUGUESE_BRAZILIAN",
1530 "PUNJABI",
1531 "QUECHUA",
1532 "RHAETO_ROMANCE",
1533 "ROMANIAN",
1534 "RUSSIAN",
1535 "RUSSIAN_UKRAINE",
1536 "SAMOAN",
1537 "SANGHO",
1538 "SANSKRIT",
1539 "SCOTS_GAELIC",
1540 "SERBIAN",
1541 "SERBIAN_CYRILLIC",
1542 "SERBIAN_LATIN",
1543 "SERBO_CROATIAN",
1544 "SESOTHO",
1545 "SETSWANA",
1546 "SHONA",
1547 "SINDHI",
1548 "SINHALESE",
1549 "SISWATI",
1550 "SLOVAK",
1551 "SLOVENIAN",
1552 "SOMALI",
1553 "SPANISH",
1554 "SPANISH_ARGENTINA",
1555 "SPANISH_BOLIVIA",
1556 "SPANISH_CHILE",
1557 "SPANISH_COLOMBIA",
1558 "SPANISH_COSTA_RICA",
1559 "SPANISH_DOMINICAN_REPUBLIC",
1560 "SPANISH_ECUADOR",
1561 "SPANISH_EL_SALVADOR",
1562 "SPANISH_GUATEMALA",
1563 "SPANISH_HONDURAS",
1564 "SPANISH_MEXICAN",
1565 "SPANISH_MODERN",
1566 "SPANISH_NICARAGUA",
1567 "SPANISH_PANAMA",
1568 "SPANISH_PARAGUAY",
1569 "SPANISH_PERU",
1570 "SPANISH_PUERTO_RICO",
1571 "SPANISH_URUGUAY",
1572 "SPANISH_US",
1573 "SPANISH_VENEZUELA",
1574 "SUNDANESE",
1575 "SWAHILI",
1576 "SWEDISH",
1577 "SWEDISH_FINLAND",
1578 "TAGALOG",
1579 "TAJIK",
1580 "TAMIL",
1581 "TATAR",
1582 "TELUGU",
1583 "THAI",
1584 "TIBETAN",
1585 "TIGRINYA",
1586 "TONGA",
1587 "TSONGA",
1588 "TURKISH",
1589 "TURKMEN",
1590 "TWI",
1591 "UIGHUR",
1592 "UKRAINIAN",
1593 "URDU",
1594 "URDU_INDIA",
1595 "URDU_PAKISTAN",
1596 "UZBEK",
1597 "UZBEK_CYRILLIC",
1598 "UZBEK_LATIN",
1599 "VIETNAMESE",
1600 "VOLAPUK",
1601 "WELSH",
1602 "WOLOF",
1603 "XHOSA",
1604 "YIDDISH",
1605 "YORUBA",
1606 "ZHUANG",
1607 "ZULU",
1608 };
1609
1610 if ( (size_t)lang < WXSIZEOF(languageNames) )
1611 return languageNames[lang];
1612 else
1613 return "INVALID";
1614 }
1615
1616 static void TestDefaultLang()
1617 {
1618 puts("*** Testing wxLocale::GetSystemLanguage ***");
1619
1620 static const wxChar *langStrings[] =
1621 {
1622 NULL, // system default
1623 _T("C"),
1624 _T("fr"),
1625 _T("fr_FR"),
1626 _T("en"),
1627 _T("en_GB"),
1628 _T("en_US"),
1629 _T("de_DE.iso88591"),
1630 _T("german"),
1631 _T("?"), // invalid lang spec
1632 _T("klingonese"), // I bet on some systems it does exist...
1633 };
1634
1635 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1636 wxLocale::GetSystemEncodingName().c_str(),
1637 wxLocale::GetSystemEncoding());
1638
1639 for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1640 {
1641 const char *langStr = langStrings[n];
1642 if ( langStr )
1643 {
1644 // FIXME: this doesn't do anything at all under Windows, we need
1645 // to create a new wxLocale!
1646 wxSetEnv(_T("LC_ALL"), langStr);
1647 }
1648
1649 int lang = gs_localeDefault.GetSystemLanguage();
1650 printf("Locale for '%s' is %s.\n",
1651 langStr ? langStr : "system default", GetLangName(lang));
1652 }
1653 }
1654
1655 #endif // TEST_LOCALE
1656
1657 // ----------------------------------------------------------------------------
1658 // MIME types
1659 // ----------------------------------------------------------------------------
1660
1661 #ifdef TEST_MIME
1662
1663 #include "wx/mimetype.h"
1664
1665 static void TestMimeEnum()
1666 {
1667 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1668
1669 wxArrayString mimetypes;
1670
1671 size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1672
1673 printf("*** All %u known filetypes: ***\n", count);
1674
1675 wxArrayString exts;
1676 wxString desc;
1677
1678 for ( size_t n = 0; n < count; n++ )
1679 {
1680 wxFileType *filetype =
1681 wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1682 if ( !filetype )
1683 {
1684 printf("nothing known about the filetype '%s'!\n",
1685 mimetypes[n].c_str());
1686 continue;
1687 }
1688
1689 filetype->GetDescription(&desc);
1690 filetype->GetExtensions(exts);
1691
1692 filetype->GetIcon(NULL);
1693
1694 wxString extsAll;
1695 for ( size_t e = 0; e < exts.GetCount(); e++ )
1696 {
1697 if ( e > 0 )
1698 extsAll << _T(", ");
1699 extsAll += exts[e];
1700 }
1701
1702 printf("\t%s: %s (%s)\n",
1703 mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1704 }
1705
1706 puts("");
1707 }
1708
1709 static void TestMimeOverride()
1710 {
1711 wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1712
1713 static const wxChar *mailcap = _T("/tmp/mailcap");
1714 static const wxChar *mimetypes = _T("/tmp/mime.types");
1715
1716 if ( wxFile::Exists(mailcap) )
1717 wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1718 mailcap,
1719 wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
1720 else
1721 wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1722 mailcap);
1723
1724 if ( wxFile::Exists(mimetypes) )
1725 wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1726 mimetypes,
1727 wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
1728 else
1729 wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1730 mimetypes);
1731
1732 puts("");
1733 }
1734
1735 static void TestMimeFilename()
1736 {
1737 wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1738
1739 static const wxChar *filenames[] =
1740 {
1741 _T("readme.txt"),
1742 _T("document.pdf"),
1743 _T("image.gif"),
1744 _T("picture.jpeg"),
1745 };
1746
1747 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1748 {
1749 const wxString fname = filenames[n];
1750 wxString ext = fname.AfterLast(_T('.'));
1751 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1752 if ( !ft )
1753 {
1754 wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1755 }
1756 else
1757 {
1758 wxString desc;
1759 if ( !ft->GetDescription(&desc) )
1760 desc = _T("<no description>");
1761
1762 wxString cmd;
1763 if ( !ft->GetOpenCommand(&cmd,
1764 wxFileType::MessageParameters(fname, _T(""))) )
1765 cmd = _T("<no command available>");
1766
1767 wxPrintf(_T("To open %s (%s) do '%s'.\n"),
1768 fname.c_str(), desc.c_str(), cmd.c_str());
1769
1770 delete ft;
1771 }
1772 }
1773
1774 puts("");
1775 }
1776
1777 static void TestMimeAssociate()
1778 {
1779 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1780
1781 wxFileTypeInfo ftInfo(
1782 _T("application/x-xyz"),
1783 _T("xyzview '%s'"), // open cmd
1784 _T(""), // print cmd
1785 _T("XYZ File"), // description
1786 _T(".xyz"), // extensions
1787 NULL // end of extensions
1788 );
1789 ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1790
1791 wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1792 if ( !ft )
1793 {
1794 wxPuts(_T("ERROR: failed to create association!"));
1795 }
1796 else
1797 {
1798 // TODO: read it back
1799 delete ft;
1800 }
1801
1802 puts("");
1803 }
1804
1805 #endif // TEST_MIME
1806
1807 // ----------------------------------------------------------------------------
1808 // misc information functions
1809 // ----------------------------------------------------------------------------
1810
1811 #ifdef TEST_INFO_FUNCTIONS
1812
1813 #include "wx/utils.h"
1814
1815 static void TestDiskInfo()
1816 {
1817 puts("*** Testing wxGetDiskSpace() ***");
1818
1819 for ( ;; )
1820 {
1821 char pathname[128];
1822 printf("\nEnter a directory name: ");
1823 if ( !fgets(pathname, WXSIZEOF(pathname), stdin) )
1824 break;
1825
1826 // kill the last '\n'
1827 pathname[strlen(pathname) - 1] = 0;
1828
1829 wxLongLong total, free;
1830 if ( !wxGetDiskSpace(pathname, &total, &free) )
1831 {
1832 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1833 }
1834 else
1835 {
1836 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1837 (total / 1024).ToString().c_str(),
1838 (free / 1024).ToString().c_str(),
1839 pathname);
1840 }
1841 }
1842 }
1843
1844 static void TestOsInfo()
1845 {
1846 puts("*** Testing OS info functions ***\n");
1847
1848 int major, minor;
1849 wxGetOsVersion(&major, &minor);
1850 printf("Running under: %s, version %d.%d\n",
1851 wxGetOsDescription().c_str(), major, minor);
1852
1853 printf("%ld free bytes of memory left.\n", wxGetFreeMemory());
1854
1855 printf("Host name is %s (%s).\n",
1856 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1857
1858 puts("");
1859 }
1860
1861 static void TestUserInfo()
1862 {
1863 puts("*** Testing user info functions ***\n");
1864
1865 printf("User id is:\t%s\n", wxGetUserId().c_str());
1866 printf("User name is:\t%s\n", wxGetUserName().c_str());
1867 printf("Home dir is:\t%s\n", wxGetHomeDir().c_str());
1868 printf("Email address:\t%s\n", wxGetEmailAddress().c_str());
1869
1870 puts("");
1871 }
1872
1873 #endif // TEST_INFO_FUNCTIONS
1874
1875 // ----------------------------------------------------------------------------
1876 // long long
1877 // ----------------------------------------------------------------------------
1878
1879 #ifdef TEST_LONGLONG
1880
1881 #include "wx/longlong.h"
1882 #include "wx/timer.h"
1883
1884 // make a 64 bit number from 4 16 bit ones
1885 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
1886
1887 // get a random 64 bit number
1888 #define RAND_LL() MAKE_LL(rand(), rand(), rand(), rand())
1889
1890 static const long testLongs[] =
1891 {
1892 0,
1893 1,
1894 -1,
1895 LONG_MAX,
1896 LONG_MIN,
1897 0x1234,
1898 -0x1234
1899 };
1900
1901 #if wxUSE_LONGLONG_WX
1902 inline bool operator==(const wxLongLongWx& a, const wxLongLongNative& b)
1903 { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
1904 inline bool operator==(const wxLongLongNative& a, const wxLongLongWx& b)
1905 { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
1906 #endif // wxUSE_LONGLONG_WX
1907
1908 static void TestSpeed()
1909 {
1910 static const long max = 100000000;
1911 long n;
1912
1913 {
1914 wxStopWatch sw;
1915
1916 long l = 0;
1917 for ( n = 0; n < max; n++ )
1918 {
1919 l += n;
1920 }
1921
1922 printf("Summing longs took %ld milliseconds.\n", sw.Time());
1923 }
1924
1925 #if wxUSE_LONGLONG_NATIVE
1926 {
1927 wxStopWatch sw;
1928
1929 wxLongLong_t l = 0;
1930 for ( n = 0; n < max; n++ )
1931 {
1932 l += n;
1933 }
1934
1935 printf("Summing wxLongLong_t took %ld milliseconds.\n", sw.Time());
1936 }
1937 #endif // wxUSE_LONGLONG_NATIVE
1938
1939 {
1940 wxStopWatch sw;
1941
1942 wxLongLong l;
1943 for ( n = 0; n < max; n++ )
1944 {
1945 l += n;
1946 }
1947
1948 printf("Summing wxLongLongs took %ld milliseconds.\n", sw.Time());
1949 }
1950 }
1951
1952 static void TestLongLongConversion()
1953 {
1954 puts("*** Testing wxLongLong conversions ***\n");
1955
1956 wxLongLong a;
1957 size_t nTested = 0;
1958 for ( size_t n = 0; n < 100000; n++ )
1959 {
1960 a = RAND_LL();
1961
1962 #if wxUSE_LONGLONG_NATIVE
1963 wxLongLongNative b(a.GetHi(), a.GetLo());
1964
1965 wxASSERT_MSG( a == b, "conversions failure" );
1966 #else
1967 puts("Can't do it without native long long type, test skipped.");
1968
1969 return;
1970 #endif // wxUSE_LONGLONG_NATIVE
1971
1972 if ( !(nTested % 1000) )
1973 {
1974 putchar('.');
1975 fflush(stdout);
1976 }
1977
1978 nTested++;
1979 }
1980
1981 puts(" done!");
1982 }
1983
1984 static void TestMultiplication()
1985 {
1986 puts("*** Testing wxLongLong multiplication ***\n");
1987
1988 wxLongLong a, b;
1989 size_t nTested = 0;
1990 for ( size_t n = 0; n < 100000; n++ )
1991 {
1992 a = RAND_LL();
1993 b = RAND_LL();
1994
1995 #if wxUSE_LONGLONG_NATIVE
1996 wxLongLongNative aa(a.GetHi(), a.GetLo());
1997 wxLongLongNative bb(b.GetHi(), b.GetLo());
1998
1999 wxASSERT_MSG( a*b == aa*bb, "multiplication failure" );
2000 #else // !wxUSE_LONGLONG_NATIVE
2001 puts("Can't do it without native long long type, test skipped.");
2002
2003 return;
2004 #endif // wxUSE_LONGLONG_NATIVE
2005
2006 if ( !(nTested % 1000) )
2007 {
2008 putchar('.');
2009 fflush(stdout);
2010 }
2011
2012 nTested++;
2013 }
2014
2015 puts(" done!");
2016 }
2017
2018 static void TestDivision()
2019 {
2020 puts("*** Testing wxLongLong division ***\n");
2021
2022 wxLongLong q, r;
2023 size_t nTested = 0;
2024 for ( size_t n = 0; n < 100000; n++ )
2025 {
2026 // get a random wxLongLong (shifting by 12 the MSB ensures that the
2027 // multiplication will not overflow)
2028 wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
2029
2030 // get a random (but non null) long (not wxLongLong for now) to divide
2031 // it with
2032 long l;
2033 do
2034 {
2035 l = rand();
2036 }
2037 while ( !l );
2038
2039 q = ll / l;
2040 r = ll % l;
2041
2042 #if wxUSE_LONGLONG_NATIVE
2043 wxLongLongNative m(ll.GetHi(), ll.GetLo());
2044
2045 wxLongLongNative p = m / l, s = m % l;
2046 wxASSERT_MSG( q == p && r == s, "division failure" );
2047 #else // !wxUSE_LONGLONG_NATIVE
2048 // verify the result
2049 wxASSERT_MSG( ll == q*l + r, "division failure" );
2050 #endif // wxUSE_LONGLONG_NATIVE
2051
2052 if ( !(nTested % 1000) )
2053 {
2054 putchar('.');
2055 fflush(stdout);
2056 }
2057
2058 nTested++;
2059 }
2060
2061 puts(" done!");
2062 }
2063
2064 static void TestAddition()
2065 {
2066 puts("*** Testing wxLongLong addition ***\n");
2067
2068 wxLongLong a, b, c;
2069 size_t nTested = 0;
2070 for ( size_t n = 0; n < 100000; n++ )
2071 {
2072 a = RAND_LL();
2073 b = RAND_LL();
2074 c = a + b;
2075
2076 #if wxUSE_LONGLONG_NATIVE
2077 wxASSERT_MSG( c == wxLongLongNative(a.GetHi(), a.GetLo()) +
2078 wxLongLongNative(b.GetHi(), b.GetLo()),
2079 "addition failure" );
2080 #else // !wxUSE_LONGLONG_NATIVE
2081 wxASSERT_MSG( c - b == a, "addition failure" );
2082 #endif // wxUSE_LONGLONG_NATIVE
2083
2084 if ( !(nTested % 1000) )
2085 {
2086 putchar('.');
2087 fflush(stdout);
2088 }
2089
2090 nTested++;
2091 }
2092
2093 puts(" done!");
2094 }
2095
2096 static void TestBitOperations()
2097 {
2098 puts("*** Testing wxLongLong bit operation ***\n");
2099
2100 wxLongLong ll;
2101 size_t nTested = 0;
2102 for ( size_t n = 0; n < 100000; n++ )
2103 {
2104 ll = RAND_LL();
2105
2106 #if wxUSE_LONGLONG_NATIVE
2107 for ( size_t n = 0; n < 33; n++ )
2108 {
2109 }
2110 #else // !wxUSE_LONGLONG_NATIVE
2111 puts("Can't do it without native long long type, test skipped.");
2112
2113 return;
2114 #endif // wxUSE_LONGLONG_NATIVE
2115
2116 if ( !(nTested % 1000) )
2117 {
2118 putchar('.');
2119 fflush(stdout);
2120 }
2121
2122 nTested++;
2123 }
2124
2125 puts(" done!");
2126 }
2127
2128 static void TestLongLongComparison()
2129 {
2130 #if wxUSE_LONGLONG_WX
2131 puts("*** Testing wxLongLong comparison ***\n");
2132
2133 static const long ls[2] =
2134 {
2135 0x1234,
2136 -0x1234,
2137 };
2138
2139 wxLongLongWx lls[2];
2140 lls[0] = ls[0];
2141 lls[1] = ls[1];
2142
2143 for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
2144 {
2145 bool res;
2146
2147 for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
2148 {
2149 res = lls[m] > testLongs[n];
2150 printf("0x%lx > 0x%lx is %s (%s)\n",
2151 ls[m], testLongs[n], res ? "true" : "false",
2152 res == (ls[m] > testLongs[n]) ? "ok" : "ERROR");
2153
2154 res = lls[m] < testLongs[n];
2155 printf("0x%lx < 0x%lx is %s (%s)\n",
2156 ls[m], testLongs[n], res ? "true" : "false",
2157 res == (ls[m] < testLongs[n]) ? "ok" : "ERROR");
2158
2159 res = lls[m] == testLongs[n];
2160 printf("0x%lx == 0x%lx is %s (%s)\n",
2161 ls[m], testLongs[n], res ? "true" : "false",
2162 res == (ls[m] == testLongs[n]) ? "ok" : "ERROR");
2163 }
2164 }
2165 #endif // wxUSE_LONGLONG_WX
2166 }
2167
2168 static void TestLongLongPrint()
2169 {
2170 wxPuts(_T("*** Testing wxLongLong printing ***\n"));
2171
2172 for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
2173 {
2174 wxLongLong ll = testLongs[n];
2175 wxPrintf(_T("%ld == %s\n"), testLongs[n], ll.ToString().c_str());
2176 }
2177
2178 wxLongLong ll(0x12345678, 0x87654321);
2179 wxPrintf(_T("0x1234567887654321 = %s\n"), ll.ToString().c_str());
2180
2181 ll.Negate();
2182 wxPrintf(_T("-0x1234567887654321 = %s\n"), ll.ToString().c_str());
2183 }
2184
2185 #undef MAKE_LL
2186 #undef RAND_LL
2187
2188 #endif // TEST_LONGLONG
2189
2190 // ----------------------------------------------------------------------------
2191 // path list
2192 // ----------------------------------------------------------------------------
2193
2194 #ifdef TEST_PATHLIST
2195
2196 static void TestPathList()
2197 {
2198 puts("*** Testing wxPathList ***\n");
2199
2200 wxPathList pathlist;
2201 pathlist.AddEnvList("PATH");
2202 wxString path = pathlist.FindValidPath("ls");
2203 if ( path.empty() )
2204 {
2205 printf("ERROR: command not found in the path.\n");
2206 }
2207 else
2208 {
2209 printf("Command found in the path as '%s'.\n", path.c_str());
2210 }
2211 }
2212
2213 #endif // TEST_PATHLIST
2214
2215 // ----------------------------------------------------------------------------
2216 // regular expressions
2217 // ----------------------------------------------------------------------------
2218
2219 #ifdef TEST_REGEX
2220
2221 #include "wx/regex.h"
2222
2223 static void TestRegExCompile()
2224 {
2225 wxPuts(_T("*** Testing RE compilation ***\n"));
2226
2227 static struct RegExCompTestData
2228 {
2229 const wxChar *pattern;
2230 bool correct;
2231 } regExCompTestData[] =
2232 {
2233 { _T("foo"), TRUE },
2234 { _T("foo("), FALSE },
2235 { _T("foo(bar"), FALSE },
2236 { _T("foo(bar)"), TRUE },
2237 { _T("foo["), FALSE },
2238 { _T("foo[bar"), FALSE },
2239 { _T("foo[bar]"), TRUE },
2240 { _T("foo{"), TRUE },
2241 { _T("foo{1"), FALSE },
2242 { _T("foo{bar"), TRUE },
2243 { _T("foo{1}"), TRUE },
2244 { _T("foo{1,2}"), TRUE },
2245 { _T("foo{bar}"), TRUE },
2246 { _T("foo*"), TRUE },
2247 { _T("foo**"), FALSE },
2248 { _T("foo+"), TRUE },
2249 { _T("foo++"), FALSE },
2250 { _T("foo?"), TRUE },
2251 { _T("foo??"), FALSE },
2252 { _T("foo?+"), FALSE },
2253 };
2254
2255 wxRegEx re;
2256 for ( size_t n = 0; n < WXSIZEOF(regExCompTestData); n++ )
2257 {
2258 const RegExCompTestData& data = regExCompTestData[n];
2259 bool ok = re.Compile(data.pattern);
2260
2261 wxPrintf(_T("'%s' is %sa valid RE (%s)\n"),
2262 data.pattern,
2263 ok ? _T("") : _T("not "),
2264 ok == data.correct ? _T("ok") : _T("ERROR"));
2265 }
2266 }
2267
2268 static void TestRegExMatch()
2269 {
2270 wxPuts(_T("*** Testing RE matching ***\n"));
2271
2272 static struct RegExMatchTestData
2273 {
2274 const wxChar *pattern;
2275 const wxChar *text;
2276 bool correct;
2277 } regExMatchTestData[] =
2278 {
2279 { _T("foo"), _T("bar"), FALSE },
2280 { _T("foo"), _T("foobar"), TRUE },
2281 { _T("^foo"), _T("foobar"), TRUE },
2282 { _T("^foo"), _T("barfoo"), FALSE },
2283 { _T("bar$"), _T("barbar"), TRUE },
2284 { _T("bar$"), _T("barbar "), FALSE },
2285 };
2286
2287 for ( size_t n = 0; n < WXSIZEOF(regExMatchTestData); n++ )
2288 {
2289 const RegExMatchTestData& data = regExMatchTestData[n];
2290
2291 wxRegEx re(data.pattern);
2292 bool ok = re.Matches(data.text);
2293
2294 wxPrintf(_T("'%s' %s %s (%s)\n"),
2295 data.pattern,
2296 ok ? _T("matches") : _T("doesn't match"),
2297 data.text,
2298 ok == data.correct ? _T("ok") : _T("ERROR"));
2299 }
2300 }
2301
2302 static void TestRegExSubmatch()
2303 {
2304 wxPuts(_T("*** Testing RE subexpressions ***\n"));
2305
2306 wxRegEx re(_T("([[:alpha:]]+) ([[:alpha:]]+) ([[:digit:]]+).*([[:digit:]]+)$"));
2307 if ( !re.IsValid() )
2308 {
2309 wxPuts(_T("ERROR: compilation failed."));
2310 return;
2311 }
2312
2313 wxString text = _T("Fri Jul 13 18:37:52 CEST 2001");
2314
2315 if ( !re.Matches(text) )
2316 {
2317 wxPuts(_T("ERROR: match expected."));
2318 }
2319 else
2320 {
2321 wxPrintf(_T("Entire match: %s\n"), re.GetMatch(text).c_str());
2322
2323 wxPrintf(_T("Date: %s/%s/%s, wday: %s\n"),
2324 re.GetMatch(text, 3).c_str(),
2325 re.GetMatch(text, 2).c_str(),
2326 re.GetMatch(text, 4).c_str(),
2327 re.GetMatch(text, 1).c_str());
2328 }
2329 }
2330
2331 static void TestRegExReplacement()
2332 {
2333 wxPuts(_T("*** Testing RE replacement ***"));
2334
2335 static struct RegExReplTestData
2336 {
2337 const wxChar *text;
2338 const wxChar *repl;
2339 const wxChar *result;
2340 size_t count;
2341 } regExReplTestData[] =
2342 {
2343 { _T("foo123"), _T("bar"), _T("bar"), 1 },
2344 { _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
2345 { _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
2346 { _T("123foo"), _T("bar"), _T("123foo"), 0 },
2347 { _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
2348 { _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
2349 { _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
2350 };
2351
2352 const wxChar *pattern = _T("([a-z]+)[^0-9]*([0-9]+)");
2353 wxRegEx re(pattern);
2354
2355 wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern);
2356
2357 for ( size_t n = 0; n < WXSIZEOF(regExReplTestData); n++ )
2358 {
2359 const RegExReplTestData& data = regExReplTestData[n];
2360
2361 wxString text = data.text;
2362 size_t nRepl = re.Replace(&text, data.repl);
2363
2364 wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
2365 data.text, data.repl,
2366 nRepl, nRepl == 1 ? _T("") : _T("es"),
2367 text.c_str());
2368 if ( text == data.result && nRepl == data.count )
2369 {
2370 wxPuts(_T("ok)"));
2371 }
2372 else
2373 {
2374 wxPrintf(_T("ERROR: should be %u and '%s')\n"),
2375 data.count, data.result);
2376 }
2377 }
2378 }
2379
2380 static void TestRegExInteractive()
2381 {
2382 wxPuts(_T("*** Testing RE interactively ***"));
2383
2384 for ( ;; )
2385 {
2386 char pattern[128];
2387 printf("\nEnter a pattern: ");
2388 if ( !fgets(pattern, WXSIZEOF(pattern), stdin) )
2389 break;
2390
2391 // kill the last '\n'
2392 pattern[strlen(pattern) - 1] = 0;
2393
2394 wxRegEx re;
2395 if ( !re.Compile(pattern) )
2396 {
2397 continue;
2398 }
2399
2400 char text[128];
2401 for ( ;; )
2402 {
2403 printf("Enter text to match: ");
2404 if ( !fgets(text, WXSIZEOF(text), stdin) )
2405 break;
2406
2407 // kill the last '\n'
2408 text[strlen(text) - 1] = 0;
2409
2410 if ( !re.Matches(text) )
2411 {
2412 printf("No match.\n");
2413 }
2414 else
2415 {
2416 printf("Pattern matches at '%s'\n", re.GetMatch(text).c_str());
2417
2418 size_t start, len;
2419 for ( size_t n = 1; ; n++ )
2420 {
2421 if ( !re.GetMatch(&start, &len, n) )
2422 {
2423 break;
2424 }
2425
2426 printf("Subexpr %u matched '%s'\n",
2427 n, wxString(text + start, len).c_str());
2428 }
2429 }
2430 }
2431 }
2432 }
2433
2434 #endif // TEST_REGEX
2435
2436 // ----------------------------------------------------------------------------
2437 // database
2438 // ----------------------------------------------------------------------------
2439
2440 #if !wxUSE_ODBC
2441 #undef TEST_ODBC
2442 #endif
2443
2444 #ifdef TEST_ODBC
2445
2446 #include <wx/db.h>
2447
2448 static void TestDbOpen()
2449 {
2450 HENV henv;
2451 wxDb db(henv);
2452 }
2453
2454 #endif // TEST_ODBC
2455
2456 // ----------------------------------------------------------------------------
2457 // registry and related stuff
2458 // ----------------------------------------------------------------------------
2459
2460 // this is for MSW only
2461 #ifndef __WXMSW__
2462 #undef TEST_REGCONF
2463 #undef TEST_REGISTRY
2464 #endif
2465
2466 #ifdef TEST_REGCONF
2467
2468 #include "wx/confbase.h"
2469 #include "wx/msw/regconf.h"
2470
2471 static void TestRegConfWrite()
2472 {
2473 wxRegConfig regconf(_T("console"), _T("wxwindows"));
2474 regconf.Write(_T("Hello"), wxString(_T("world")));
2475 }
2476
2477 #endif // TEST_REGCONF
2478
2479 #ifdef TEST_REGISTRY
2480
2481 #include "wx/msw/registry.h"
2482
2483 // I chose this one because I liked its name, but it probably only exists under
2484 // NT
2485 static const wxChar *TESTKEY =
2486 _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2487
2488 static void TestRegistryRead()
2489 {
2490 puts("*** testing registry reading ***");
2491
2492 wxRegKey key(TESTKEY);
2493 printf("The test key name is '%s'.\n", key.GetName().c_str());
2494 if ( !key.Open() )
2495 {
2496 puts("ERROR: test key can't be opened, aborting test.");
2497
2498 return;
2499 }
2500
2501 size_t nSubKeys, nValues;
2502 if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
2503 {
2504 printf("It has %u subkeys and %u values.\n", nSubKeys, nValues);
2505 }
2506
2507 printf("Enumerating values:\n");
2508
2509 long dummy;
2510 wxString value;
2511 bool cont = key.GetFirstValue(value, dummy);
2512 while ( cont )
2513 {
2514 printf("Value '%s': type ", value.c_str());
2515 switch ( key.GetValueType(value) )
2516 {
2517 case wxRegKey::Type_None: printf("ERROR (none)"); break;
2518 case wxRegKey::Type_String: printf("SZ"); break;
2519 case wxRegKey::Type_Expand_String: printf("EXPAND_SZ"); break;
2520 case wxRegKey::Type_Binary: printf("BINARY"); break;
2521 case wxRegKey::Type_Dword: printf("DWORD"); break;
2522 case wxRegKey::Type_Multi_String: printf("MULTI_SZ"); break;
2523 default: printf("other (unknown)"); break;
2524 }
2525
2526 printf(", value = ");
2527 if ( key.IsNumericValue(value) )
2528 {
2529 long val;
2530 key.QueryValue(value, &val);
2531 printf("%ld", val);
2532 }
2533 else // string
2534 {
2535 wxString val;
2536 key.QueryValue(value, val);
2537 printf("'%s'", val.c_str());
2538
2539 key.QueryRawValue(value, val);
2540 printf(" (raw value '%s')", val.c_str());
2541 }
2542
2543 putchar('\n');
2544
2545 cont = key.GetNextValue(value, dummy);
2546 }
2547 }
2548
2549 static void TestRegistryAssociation()
2550 {
2551 /*
2552 The second call to deleteself genertaes an error message, with a
2553 messagebox saying .flo is crucial to system operation, while the .ddf
2554 call also fails, but with no error message
2555 */
2556
2557 wxRegKey key;
2558
2559 key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
2560 key.Create();
2561 key = "ddxf_auto_file" ;
2562 key.SetName("HKEY_CLASSES_ROOT\\.flo" );
2563 key.Create();
2564 key = "ddxf_auto_file" ;
2565 key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
2566 key.Create();
2567 key = "program,0" ;
2568 key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
2569 key.Create();
2570 key = "program \"%1\"" ;
2571
2572 key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
2573 key.DeleteSelf();
2574 key.SetName("HKEY_CLASSES_ROOT\\.flo" );
2575 key.DeleteSelf();
2576 key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
2577 key.DeleteSelf();
2578 key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
2579 key.DeleteSelf();
2580 }
2581
2582 #endif // TEST_REGISTRY
2583
2584 // ----------------------------------------------------------------------------
2585 // sockets
2586 // ----------------------------------------------------------------------------
2587
2588 #ifdef TEST_SOCKETS
2589
2590 #include "wx/socket.h"
2591 #include "wx/protocol/protocol.h"
2592 #include "wx/protocol/http.h"
2593
2594 static void TestSocketServer()
2595 {
2596 puts("*** Testing wxSocketServer ***\n");
2597
2598 static const int PORT = 3000;
2599
2600 wxIPV4address addr;
2601 addr.Service(PORT);
2602
2603 wxSocketServer *server = new wxSocketServer(addr);
2604 if ( !server->Ok() )
2605 {
2606 puts("ERROR: failed to bind");
2607
2608 return;
2609 }
2610
2611 for ( ;; )
2612 {
2613 printf("Server: waiting for connection on port %d...\n", PORT);
2614
2615 wxSocketBase *socket = server->Accept();
2616 if ( !socket )
2617 {
2618 puts("ERROR: wxSocketServer::Accept() failed.");
2619 break;
2620 }
2621
2622 puts("Server: got a client.");
2623
2624 server->SetTimeout(60); // 1 min
2625
2626 while ( socket->IsConnected() )
2627 {
2628 wxString s;
2629 char ch = '\0';
2630 for ( ;; )
2631 {
2632 if ( socket->Read(&ch, sizeof(ch)).Error() )
2633 {
2634 // don't log error if the client just close the connection
2635 if ( socket->IsConnected() )
2636 {
2637 puts("ERROR: in wxSocket::Read.");
2638 }
2639
2640 break;
2641 }
2642
2643 if ( ch == '\r' )
2644 continue;
2645
2646 if ( ch == '\n' )
2647 break;
2648
2649 s += ch;
2650 }
2651
2652 if ( ch != '\n' )
2653 {
2654 break;
2655 }
2656
2657 printf("Server: got '%s'.\n", s.c_str());
2658 if ( s == _T("bye") )
2659 {
2660 delete socket;
2661
2662 break;
2663 }
2664
2665 socket->Write(s.MakeUpper().c_str(), s.length());
2666 socket->Write("\r\n", 2);
2667 printf("Server: wrote '%s'.\n", s.c_str());
2668 }
2669
2670 puts("Server: lost a client.");
2671
2672 socket->Destroy();
2673 }
2674
2675 // same as "delete server" but is consistent with GUI programs
2676 server->Destroy();
2677 }
2678
2679 static void TestSocketClient()
2680 {
2681 puts("*** Testing wxSocketClient ***\n");
2682
2683 static const char *hostname = "www.wxwindows.org";
2684
2685 wxIPV4address addr;
2686 addr.Hostname(hostname);
2687 addr.Service(80);
2688
2689 printf("--- Attempting to connect to %s:80...\n", hostname);
2690
2691 wxSocketClient client;
2692 if ( !client.Connect(addr) )
2693 {
2694 printf("ERROR: failed to connect to %s\n", hostname);
2695 }
2696 else
2697 {
2698 printf("--- Connected to %s:%u...\n",
2699 addr.Hostname().c_str(), addr.Service());
2700
2701 char buf[8192];
2702
2703 // could use simply "GET" here I suppose
2704 wxString cmdGet =
2705 wxString::Format("GET http://%s/\r\n", hostname);
2706 client.Write(cmdGet, cmdGet.length());
2707 printf("--- Sent command '%s' to the server\n",
2708 MakePrintable(cmdGet).c_str());
2709 client.Read(buf, WXSIZEOF(buf));
2710 printf("--- Server replied:\n%s", buf);
2711 }
2712 }
2713
2714 #endif // TEST_SOCKETS
2715
2716 // ----------------------------------------------------------------------------
2717 // FTP
2718 // ----------------------------------------------------------------------------
2719
2720 #ifdef TEST_FTP
2721
2722 #include "wx/protocol/ftp.h"
2723
2724 static wxFTP ftp;
2725
2726 #define FTP_ANONYMOUS
2727
2728 #ifdef FTP_ANONYMOUS
2729 static const char *directory = "/pub";
2730 static const char *filename = "welcome.msg";
2731 #else
2732 static const char *directory = "/etc";
2733 static const char *filename = "issue";
2734 #endif
2735
2736 static bool TestFtpConnect()
2737 {
2738 puts("*** Testing FTP connect ***");
2739
2740 #ifdef FTP_ANONYMOUS
2741 static const char *hostname = "ftp.wxwindows.org";
2742
2743 printf("--- Attempting to connect to %s:21 anonymously...\n", hostname);
2744 #else // !FTP_ANONYMOUS
2745 static const char *hostname = "localhost";
2746
2747 char user[256];
2748 fgets(user, WXSIZEOF(user), stdin);
2749 user[strlen(user) - 1] = '\0'; // chop off '\n'
2750 ftp.SetUser(user);
2751
2752 char password[256];
2753 printf("Password for %s: ", password);
2754 fgets(password, WXSIZEOF(password), stdin);
2755 password[strlen(password) - 1] = '\0'; // chop off '\n'
2756 ftp.SetPassword(password);
2757
2758 printf("--- Attempting to connect to %s:21 as %s...\n", hostname, user);
2759 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2760
2761 if ( !ftp.Connect(hostname) )
2762 {
2763 printf("ERROR: failed to connect to %s\n", hostname);
2764
2765 return FALSE;
2766 }
2767 else
2768 {
2769 printf("--- Connected to %s, current directory is '%s'\n",
2770 hostname, ftp.Pwd().c_str());
2771 }
2772
2773 return TRUE;
2774 }
2775
2776 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2777 static void TestFtpWuFtpd()
2778 {
2779 wxFTP ftp;
2780 static const char *hostname = "ftp.eudora.com";
2781 if ( !ftp.Connect(hostname) )
2782 {
2783 printf("ERROR: failed to connect to %s\n", hostname);
2784 }
2785 else
2786 {
2787 static const char *filename = "eudora/pubs/draft-gellens-submit-09.txt";
2788 wxInputStream *in = ftp.GetInputStream(filename);
2789 if ( !in )
2790 {
2791 printf("ERROR: couldn't get input stream for %s\n", filename);
2792 }
2793 else
2794 {
2795 size_t size = in->StreamSize();
2796 printf("Reading file %s (%u bytes)...", filename, size);
2797
2798 char *data = new char[size];
2799 if ( !in->Read(data, size) )
2800 {
2801 puts("ERROR: read error");
2802 }
2803 else
2804 {
2805 printf("Successfully retrieved the file.\n");
2806 }
2807
2808 delete [] data;
2809 delete in;
2810 }
2811 }
2812 }
2813
2814 static void TestFtpList()
2815 {
2816 puts("*** Testing wxFTP file listing ***\n");
2817
2818 // test CWD
2819 if ( !ftp.ChDir(directory) )
2820 {
2821 printf("ERROR: failed to cd to %s\n", directory);
2822 }
2823
2824 printf("Current directory is '%s'\n", ftp.Pwd().c_str());
2825
2826 // test NLIST and LIST
2827 wxArrayString files;
2828 if ( !ftp.GetFilesList(files) )
2829 {
2830 puts("ERROR: failed to get NLIST of files");
2831 }
2832 else
2833 {
2834 printf("Brief list of files under '%s':\n", ftp.Pwd().c_str());
2835 size_t count = files.GetCount();
2836 for ( size_t n = 0; n < count; n++ )
2837 {
2838 printf("\t%s\n", files[n].c_str());
2839 }
2840 puts("End of the file list");
2841 }
2842
2843 if ( !ftp.GetDirList(files) )
2844 {
2845 puts("ERROR: failed to get LIST of files");
2846 }
2847 else
2848 {
2849 printf("Detailed list of files under '%s':\n", ftp.Pwd().c_str());
2850 size_t count = files.GetCount();
2851 for ( size_t n = 0; n < count; n++ )
2852 {
2853 printf("\t%s\n", files[n].c_str());
2854 }
2855 puts("End of the file list");
2856 }
2857
2858 if ( !ftp.ChDir(_T("..")) )
2859 {
2860 puts("ERROR: failed to cd to ..");
2861 }
2862
2863 printf("Current directory is '%s'\n", ftp.Pwd().c_str());
2864 }
2865
2866 static void TestFtpDownload()
2867 {
2868 puts("*** Testing wxFTP download ***\n");
2869
2870 // test RETR
2871 wxInputStream *in = ftp.GetInputStream(filename);
2872 if ( !in )
2873 {
2874 printf("ERROR: couldn't get input stream for %s\n", filename);
2875 }
2876 else
2877 {
2878 size_t size = in->StreamSize();
2879 printf("Reading file %s (%u bytes)...", filename, size);
2880 fflush(stdout);
2881
2882 char *data = new char[size];
2883 if ( !in->Read(data, size) )
2884 {
2885 puts("ERROR: read error");
2886 }
2887 else
2888 {
2889 printf("\nContents of %s:\n%s\n", filename, data);
2890 }
2891
2892 delete [] data;
2893 delete in;
2894 }
2895 }
2896
2897 static void TestFtpFileSize()
2898 {
2899 puts("*** Testing FTP SIZE command ***");
2900
2901 if ( !ftp.ChDir(directory) )
2902 {
2903 printf("ERROR: failed to cd to %s\n", directory);
2904 }
2905
2906 printf("Current directory is '%s'\n", ftp.Pwd().c_str());
2907
2908 if ( ftp.FileExists(filename) )
2909 {
2910 int size = ftp.GetFileSize(filename);
2911 if ( size == -1 )
2912 printf("ERROR: couldn't get size of '%s'\n", filename);
2913 else
2914 printf("Size of '%s' is %d bytes.\n", filename, size);
2915 }
2916 else
2917 {
2918 printf("ERROR: '%s' doesn't exist\n", filename);
2919 }
2920 }
2921
2922 static void TestFtpMisc()
2923 {
2924 puts("*** Testing miscellaneous wxFTP functions ***");
2925
2926 if ( ftp.SendCommand("STAT") != '2' )
2927 {
2928 puts("ERROR: STAT failed");
2929 }
2930 else
2931 {
2932 printf("STAT returned:\n\n%s\n", ftp.GetLastResult().c_str());
2933 }
2934
2935 if ( ftp.SendCommand("HELP SITE") != '2' )
2936 {
2937 puts("ERROR: HELP SITE failed");
2938 }
2939 else
2940 {
2941 printf("The list of site-specific commands:\n\n%s\n",
2942 ftp.GetLastResult().c_str());
2943 }
2944 }
2945
2946 static void TestFtpInteractive()
2947 {
2948 puts("\n*** Interactive wxFTP test ***");
2949
2950 char buf[128];
2951
2952 for ( ;; )
2953 {
2954 printf("Enter FTP command: ");
2955 if ( !fgets(buf, WXSIZEOF(buf), stdin) )
2956 break;
2957
2958 // kill the last '\n'
2959 buf[strlen(buf) - 1] = 0;
2960
2961 // special handling of LIST and NLST as they require data connection
2962 wxString start(buf, 4);
2963 start.MakeUpper();
2964 if ( start == "LIST" || start == "NLST" )
2965 {
2966 wxString wildcard;
2967 if ( strlen(buf) > 4 )
2968 wildcard = buf + 5;
2969
2970 wxArrayString files;
2971 if ( !ftp.GetList(files, wildcard, start == "LIST") )
2972 {
2973 printf("ERROR: failed to get %s of files\n", start.c_str());
2974 }
2975 else
2976 {
2977 printf("--- %s of '%s' under '%s':\n",
2978 start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
2979 size_t count = files.GetCount();
2980 for ( size_t n = 0; n < count; n++ )
2981 {
2982 printf("\t%s\n", files[n].c_str());
2983 }
2984 puts("--- End of the file list");
2985 }
2986 }
2987 else // !list
2988 {
2989 char ch = ftp.SendCommand(buf);
2990 printf("Command %s", ch ? "succeeded" : "failed");
2991 if ( ch )
2992 {
2993 printf(" (return code %c)", ch);
2994 }
2995
2996 printf(", server reply:\n%s\n\n", ftp.GetLastResult().c_str());
2997 }
2998 }
2999
3000 puts("\n*** done ***");
3001 }
3002
3003 static void TestFtpUpload()
3004 {
3005 puts("*** Testing wxFTP uploading ***\n");
3006
3007 // upload a file
3008 static const char *file1 = "test1";
3009 static const char *file2 = "test2";
3010 wxOutputStream *out = ftp.GetOutputStream(file1);
3011 if ( out )
3012 {
3013 printf("--- Uploading to %s ---\n", file1);
3014 out->Write("First hello", 11);
3015 delete out;
3016 }
3017
3018 // send a command to check the remote file
3019 if ( ftp.SendCommand(wxString("STAT ") + file1) != '2' )
3020 {
3021 printf("ERROR: STAT %s failed\n", file1);
3022 }
3023 else
3024 {
3025 printf("STAT %s returned:\n\n%s\n",
3026 file1, ftp.GetLastResult().c_str());
3027 }
3028
3029 out = ftp.GetOutputStream(file2);
3030 if ( out )
3031 {
3032 printf("--- Uploading to %s ---\n", file1);
3033 out->Write("Second hello", 12);
3034 delete out;
3035 }
3036 }
3037
3038 #endif // TEST_FTP
3039
3040 // ----------------------------------------------------------------------------
3041 // streams
3042 // ----------------------------------------------------------------------------
3043
3044 #ifdef TEST_STREAMS
3045
3046 #include "wx/wfstream.h"
3047 #include "wx/mstream.h"
3048
3049 static void TestFileStream()
3050 {
3051 puts("*** Testing wxFileInputStream ***");
3052
3053 static const wxChar *filename = _T("testdata.fs");
3054 {
3055 wxFileOutputStream fsOut(filename);
3056 fsOut.Write("foo", 3);
3057 }
3058
3059 wxFileInputStream fsIn(filename);
3060 printf("File stream size: %u\n", fsIn.GetSize());
3061 while ( !fsIn.Eof() )
3062 {
3063 putchar(fsIn.GetC());
3064 }
3065
3066 if ( !wxRemoveFile(filename) )
3067 {
3068 printf("ERROR: failed to remove the file '%s'.\n", filename);
3069 }
3070
3071 puts("\n*** wxFileInputStream test done ***");
3072 }
3073
3074 static void TestMemoryStream()
3075 {
3076 wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
3077
3078 wxMemoryOutputStream memOutStream;
3079 wxPrintf(_T("Initially out stream offset: %lu\n"),
3080 (unsigned long)memOutStream.TellO());
3081
3082 for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
3083 {
3084 memOutStream.PutC(*p);
3085 }
3086
3087 wxPrintf(_T("Final out stream offset: %lu\n"),
3088 (unsigned long)memOutStream.TellO());
3089
3090 wxPuts(_T("*** Testing wxMemoryInputStream ***"));
3091
3092 wxChar buf[1024];
3093 size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
3094
3095 wxMemoryInputStream memInpStream(buf, len);
3096 wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
3097 while ( !memInpStream.Eof() )
3098 {
3099 putchar(memInpStream.GetC());
3100 }
3101
3102 puts("\n*** wxMemoryInputStream test done ***");
3103 }
3104
3105 #endif // TEST_STREAMS
3106
3107 // ----------------------------------------------------------------------------
3108 // timers
3109 // ----------------------------------------------------------------------------
3110
3111 #ifdef TEST_TIMER
3112
3113 #include "wx/timer.h"
3114 #include "wx/utils.h"
3115
3116 static void TestStopWatch()
3117 {
3118 puts("*** Testing wxStopWatch ***\n");
3119
3120 wxStopWatch sw;
3121 sw.Pause();
3122 printf("Initially paused, after 2 seconds time is...");
3123 fflush(stdout);
3124 wxSleep(2);
3125 printf("\t%ldms\n", sw.Time());
3126
3127 printf("Resuming stopwatch and sleeping 3 seconds...");
3128 fflush(stdout);
3129 sw.Resume();
3130 wxSleep(3);
3131 printf("\telapsed time: %ldms\n", sw.Time());
3132
3133 sw.Pause();
3134 printf("Pausing agan and sleeping 2 more seconds...");
3135 fflush(stdout);
3136 wxSleep(2);
3137 printf("\telapsed time: %ldms\n", sw.Time());
3138
3139 sw.Resume();
3140 printf("Finally resuming and sleeping 2 more seconds...");
3141 fflush(stdout);
3142 wxSleep(2);
3143 printf("\telapsed time: %ldms\n", sw.Time());
3144
3145 wxStopWatch sw2;
3146 puts("\nChecking for 'backwards clock' bug...");
3147 for ( size_t n = 0; n < 70; n++ )
3148 {
3149 sw2.Start();
3150
3151 for ( size_t m = 0; m < 100000; m++ )
3152 {
3153 if ( sw.Time() < 0 || sw2.Time() < 0 )
3154 {
3155 puts("\ntime is negative - ERROR!");
3156 }
3157 }
3158
3159 putchar('.');
3160 fflush(stdout);
3161 }
3162
3163 puts(", ok.");
3164 }
3165
3166 #endif // TEST_TIMER
3167
3168 // ----------------------------------------------------------------------------
3169 // vCard support
3170 // ----------------------------------------------------------------------------
3171
3172 #ifdef TEST_VCARD
3173
3174 #include "wx/vcard.h"
3175
3176 static void DumpVObject(size_t level, const wxVCardObject& vcard)
3177 {
3178 void *cookie;
3179 wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3180 while ( vcObj )
3181 {
3182 printf("%s%s",
3183 wxString(_T('\t'), level).c_str(),
3184 vcObj->GetName().c_str());
3185
3186 wxString value;
3187 switch ( vcObj->GetType() )
3188 {
3189 case wxVCardObject::String:
3190 case wxVCardObject::UString:
3191 {
3192 wxString val;
3193 vcObj->GetValue(&val);
3194 value << _T('"') << val << _T('"');
3195 }
3196 break;
3197
3198 case wxVCardObject::Int:
3199 {
3200 unsigned int i;
3201 vcObj->GetValue(&i);
3202 value.Printf(_T("%u"), i);
3203 }
3204 break;
3205
3206 case wxVCardObject::Long:
3207 {
3208 unsigned long l;
3209 vcObj->GetValue(&l);
3210 value.Printf(_T("%lu"), l);
3211 }
3212 break;
3213
3214 case wxVCardObject::None:
3215 break;
3216
3217 case wxVCardObject::Object:
3218 value = _T("<node>");
3219 break;
3220
3221 default:
3222 value = _T("<unknown value type>");
3223 }
3224
3225 if ( !!value )
3226 printf(" = %s", value.c_str());
3227 putchar('\n');
3228
3229 DumpVObject(level + 1, *vcObj);
3230
3231 delete vcObj;
3232 vcObj = vcard.GetNextProp(&cookie);
3233 }
3234 }
3235
3236 static void DumpVCardAddresses(const wxVCard& vcard)
3237 {
3238 puts("\nShowing all addresses from vCard:\n");
3239
3240 size_t nAdr = 0;
3241 void *cookie;
3242 wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3243 while ( addr )
3244 {
3245 wxString flagsStr;
3246 int flags = addr->GetFlags();
3247 if ( flags & wxVCardAddress::Domestic )
3248 {
3249 flagsStr << _T("domestic ");
3250 }
3251 if ( flags & wxVCardAddress::Intl )
3252 {
3253 flagsStr << _T("international ");
3254 }
3255 if ( flags & wxVCardAddress::Postal )
3256 {
3257 flagsStr << _T("postal ");
3258 }
3259 if ( flags & wxVCardAddress::Parcel )
3260 {
3261 flagsStr << _T("parcel ");
3262 }
3263 if ( flags & wxVCardAddress::Home )
3264 {
3265 flagsStr << _T("home ");
3266 }
3267 if ( flags & wxVCardAddress::Work )
3268 {
3269 flagsStr << _T("work ");
3270 }
3271
3272 printf("Address %u:\n"
3273 "\tflags = %s\n"
3274 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3275 ++nAdr,
3276 flagsStr.c_str(),
3277 addr->GetPostOffice().c_str(),
3278 addr->GetExtAddress().c_str(),
3279 addr->GetStreet().c_str(),
3280 addr->GetLocality().c_str(),
3281 addr->GetRegion().c_str(),
3282 addr->GetPostalCode().c_str(),
3283 addr->GetCountry().c_str()
3284 );
3285
3286 delete addr;
3287 addr = vcard.GetNextAddress(&cookie);
3288 }
3289 }
3290
3291 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
3292 {
3293 puts("\nShowing all phone numbers from vCard:\n");
3294
3295 size_t nPhone = 0;
3296 void *cookie;
3297 wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
3298 while ( phone )
3299 {
3300 wxString flagsStr;
3301 int flags = phone->GetFlags();
3302 if ( flags & wxVCardPhoneNumber::Voice )
3303 {
3304 flagsStr << _T("voice ");
3305 }
3306 if ( flags & wxVCardPhoneNumber::Fax )
3307 {
3308 flagsStr << _T("fax ");
3309 }
3310 if ( flags & wxVCardPhoneNumber::Cellular )
3311 {
3312 flagsStr << _T("cellular ");
3313 }
3314 if ( flags & wxVCardPhoneNumber::Modem )
3315 {
3316 flagsStr << _T("modem ");
3317 }
3318 if ( flags & wxVCardPhoneNumber::Home )
3319 {
3320 flagsStr << _T("home ");
3321 }
3322 if ( flags & wxVCardPhoneNumber::Work )
3323 {
3324 flagsStr << _T("work ");
3325 }
3326
3327 printf("Phone number %u:\n"
3328 "\tflags = %s\n"
3329 "\tvalue = %s\n",
3330 ++nPhone,
3331 flagsStr.c_str(),
3332 phone->GetNumber().c_str()
3333 );
3334
3335 delete phone;
3336 phone = vcard.GetNextPhoneNumber(&cookie);
3337 }
3338 }
3339
3340 static void TestVCardRead()
3341 {
3342 puts("*** Testing wxVCard reading ***\n");
3343
3344 wxVCard vcard(_T("vcard.vcf"));
3345 if ( !vcard.IsOk() )
3346 {
3347 puts("ERROR: couldn't load vCard.");
3348 }
3349 else
3350 {
3351 // read individual vCard properties
3352 wxVCardObject *vcObj = vcard.GetProperty("FN");
3353 wxString value;
3354 if ( vcObj )
3355 {
3356 vcObj->GetValue(&value);
3357 delete vcObj;
3358 }
3359 else
3360 {
3361 value = _T("<none>");
3362 }
3363
3364 printf("Full name retrieved directly: %s\n", value.c_str());
3365
3366
3367 if ( !vcard.GetFullName(&value) )
3368 {
3369 value = _T("<none>");
3370 }
3371
3372 printf("Full name from wxVCard API: %s\n", value.c_str());
3373
3374 // now show how to deal with multiply occuring properties
3375 DumpVCardAddresses(vcard);
3376 DumpVCardPhoneNumbers(vcard);
3377
3378 // and finally show all
3379 puts("\nNow dumping the entire vCard:\n"
3380 "-----------------------------\n");
3381
3382 DumpVObject(0, vcard);
3383 }
3384 }
3385
3386 static void TestVCardWrite()
3387 {
3388 puts("*** Testing wxVCard writing ***\n");
3389
3390 wxVCard vcard;
3391 if ( !vcard.IsOk() )
3392 {
3393 puts("ERROR: couldn't create vCard.");
3394 }
3395 else
3396 {
3397 // set some fields
3398 vcard.SetName("Zeitlin", "Vadim");
3399 vcard.SetFullName("Vadim Zeitlin");
3400 vcard.SetOrganization("wxWindows", "R&D");
3401
3402 // just dump the vCard back
3403 puts("Entire vCard follows:\n");
3404 puts(vcard.Write());
3405 }
3406 }
3407
3408 #endif // TEST_VCARD
3409
3410 // ----------------------------------------------------------------------------
3411 // wxVolume tests
3412 // ----------------------------------------------------------------------------
3413
3414 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
3415 #undef TEST_VOLUME
3416 #endif
3417
3418 #ifdef TEST_VOLUME
3419
3420 #include "wx/volume.h"
3421
3422 static const wxChar *volumeKinds[] =
3423 {
3424 _T("floppy"),
3425 _T("hard disk"),
3426 _T("CD-ROM"),
3427 _T("DVD-ROM"),
3428 _T("network volume"),
3429 _T("other volume"),
3430 };
3431
3432 static void TestFSVolume()
3433 {
3434 wxPuts(_T("*** Testing wxFSVolume class ***"));
3435
3436 wxArrayString volumes = wxFSVolume::GetVolumes();
3437 size_t count = volumes.GetCount();
3438
3439 if ( !count )
3440 {
3441 wxPuts(_T("ERROR: no mounted volumes?"));
3442 return;
3443 }
3444
3445 wxPrintf(_T("%u mounted volumes found:\n"), count);
3446
3447 for ( size_t n = 0; n < count; n++ )
3448 {
3449 wxFSVolume vol(volumes[n]);
3450 if ( !vol.IsOk() )
3451 {
3452 wxPuts(_T("ERROR: couldn't create volume"));
3453 continue;
3454 }
3455
3456 wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3457 n + 1,
3458 vol.GetDisplayName().c_str(),
3459 vol.GetName().c_str(),
3460 volumeKinds[vol.GetKind()],
3461 vol.IsWritable() ? _T("rw") : _T("ro"),
3462 vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3463 : _T("fixed"));
3464 }
3465 }
3466
3467 #endif // TEST_VOLUME
3468
3469 // ----------------------------------------------------------------------------
3470 // wide char and Unicode support
3471 // ----------------------------------------------------------------------------
3472
3473 #ifdef TEST_UNICODE
3474
3475 static void TestUnicodeToFromAscii()
3476 {
3477 wxPuts(_T("Testing wxString::To/FromAscii()\n"));
3478
3479 static const char *msg = "Hello, world!";
3480 wxString s = wxString::FromAscii(msg);
3481
3482 wxPrintf(_T("Message in Unicode: %s\n"), s.c_str());
3483 printf("Message in ASCII: %s\n", s.ToAscii());
3484
3485 wxPutchar(_T('\n'));
3486 }
3487
3488 #endif // TEST_UNICODE
3489
3490 #ifdef TEST_WCHAR
3491
3492 #include "wx/strconv.h"
3493 #include "wx/fontenc.h"
3494 #include "wx/encconv.h"
3495 #include "wx/buffer.h"
3496
3497 static const char textInUtf8[] =
3498 {
3499 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3500 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3501 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3502 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3503 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3504 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3505 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3506 };
3507
3508 static void TestUtf8()
3509 {
3510 puts("*** Testing UTF8 support ***\n");
3511
3512 char buf[1024];
3513 wchar_t wbuf[1024];
3514 if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
3515 {
3516 puts("ERROR: UTF-8 decoding failed.");
3517 }
3518 else
3519 {
3520 wxCSConv conv(_T("koi8-r"));
3521 if ( conv.WC2MB(buf, wbuf, 0 /* not needed wcslen(wbuf) */) <= 0 )
3522 {
3523 puts("ERROR: conversion to KOI8-R failed.");
3524 }
3525 else
3526 {
3527 printf("The resulting string (in KOI8-R): %s\n", buf);
3528 }
3529 }
3530
3531 if ( wxConvUTF8.WC2MB(buf, L"à la", WXSIZEOF(buf)) <= 0 )
3532 {
3533 puts("ERROR: conversion to UTF-8 failed.");
3534 }
3535 else
3536 {
3537 printf("The string in UTF-8: %s\n", buf);
3538 }
3539
3540 puts("");
3541 }
3542
3543 static void TestEncodingConverter()
3544 {
3545 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3546
3547 // using wxEncodingConverter should give the same result as above
3548 char buf[1024];
3549 wchar_t wbuf[1024];
3550 if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
3551 {
3552 puts("ERROR: UTF-8 decoding failed.");
3553 }
3554 else
3555 {
3556 wxEncodingConverter ec;
3557 ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3558 ec.Convert(wbuf, buf);
3559 printf("The same string obtained using wxEC: %s\n", buf);
3560 }
3561
3562 puts("");
3563 }
3564
3565 #endif // TEST_WCHAR
3566
3567 // ----------------------------------------------------------------------------
3568 // ZIP stream
3569 // ----------------------------------------------------------------------------
3570
3571 #ifdef TEST_ZIP
3572
3573 #include "wx/filesys.h"
3574 #include "wx/fs_zip.h"
3575 #include "wx/zipstrm.h"
3576
3577 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3578
3579 static void TestZipStreamRead()
3580 {
3581 puts("*** Testing ZIP reading ***\n");
3582
3583 static const wxChar *filename = _T("foo");
3584 wxZipInputStream istr(TESTFILE_ZIP, filename);
3585 printf("Archive size: %u\n", istr.GetSize());
3586
3587 printf("Dumping the file '%s':\n", filename);
3588 while ( !istr.Eof() )
3589 {
3590 putchar(istr.GetC());
3591 fflush(stdout);
3592 }
3593
3594 puts("\n----- done ------");
3595 }
3596
3597 static void DumpZipDirectory(wxFileSystem& fs,
3598 const wxString& dir,
3599 const wxString& indent)
3600 {
3601 wxString prefix = wxString::Format(_T("%s#zip:%s"),
3602 TESTFILE_ZIP, dir.c_str());
3603 wxString wildcard = prefix + _T("/*");
3604
3605 wxString dirname = fs.FindFirst(wildcard, wxDIR);
3606 while ( !dirname.empty() )
3607 {
3608 if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3609 {
3610 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3611
3612 break;
3613 }
3614
3615 wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3616
3617 DumpZipDirectory(fs, dirname,
3618 indent + wxString(_T(' '), 4));
3619
3620 dirname = fs.FindNext();
3621 }
3622
3623 wxString filename = fs.FindFirst(wildcard, wxFILE);
3624 while ( !filename.empty() )
3625 {
3626 if ( !filename.StartsWith(prefix, &filename) )
3627 {
3628 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3629
3630 break;
3631 }
3632
3633 wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3634
3635 filename = fs.FindNext();
3636 }
3637 }
3638
3639 static void TestZipFileSystem()
3640 {
3641 puts("*** Testing ZIP file system ***\n");
3642
3643 wxFileSystem::AddHandler(new wxZipFSHandler);
3644 wxFileSystem fs;
3645 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3646
3647 DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3648 }
3649
3650 #endif // TEST_ZIP
3651
3652 // ----------------------------------------------------------------------------
3653 // ZLIB stream
3654 // ----------------------------------------------------------------------------
3655
3656 #ifdef TEST_ZLIB
3657
3658 #include "wx/zstream.h"
3659 #include "wx/wfstream.h"
3660
3661 static const wxChar *FILENAME_GZ = _T("test.gz");
3662 static const char *TEST_DATA = "hello and hello and hello and hello and hello";
3663
3664 static void TestZlibStreamWrite()
3665 {
3666 puts("*** Testing Zlib stream reading ***\n");
3667
3668 wxFileOutputStream fileOutStream(FILENAME_GZ);
3669 wxZlibOutputStream ostr(fileOutStream);
3670 printf("Compressing the test string... ");
3671 ostr.Write(TEST_DATA, strlen(TEST_DATA) + 1);
3672 if ( !ostr )
3673 {
3674 puts("(ERROR: failed)");
3675 }
3676 else
3677 {
3678 puts("(ok)");
3679 }
3680
3681 puts("\n----- done ------");
3682 }
3683
3684 static void TestZlibStreamRead()
3685 {
3686 puts("*** Testing Zlib stream reading ***\n");
3687
3688 wxFileInputStream fileInStream(FILENAME_GZ);
3689 wxZlibInputStream istr(fileInStream);
3690 printf("Archive size: %u\n", istr.GetSize());
3691
3692 puts("Dumping the file:");
3693 while ( !istr.Eof() )
3694 {
3695 putchar(istr.GetC());
3696 fflush(stdout);
3697 }
3698
3699 puts("\n----- done ------");
3700 }
3701
3702 #endif // TEST_ZLIB
3703
3704 // ----------------------------------------------------------------------------
3705 // date time
3706 // ----------------------------------------------------------------------------
3707
3708 #ifdef TEST_DATETIME
3709
3710 #include <math.h>
3711
3712 #include "wx/date.h"
3713 #include "wx/datetime.h"
3714
3715 // the test data
3716 struct Date
3717 {
3718 wxDateTime::wxDateTime_t day;
3719 wxDateTime::Month month;
3720 int year;
3721 wxDateTime::wxDateTime_t hour, min, sec;
3722 double jdn;
3723 wxDateTime::WeekDay wday;
3724 time_t gmticks, ticks;
3725
3726 void Init(const wxDateTime::Tm& tm)
3727 {
3728 day = tm.mday;
3729 month = tm.mon;
3730 year = tm.year;
3731 hour = tm.hour;
3732 min = tm.min;
3733 sec = tm.sec;
3734 jdn = 0.0;
3735 gmticks = ticks = -1;
3736 }
3737
3738 wxDateTime DT() const
3739 { return wxDateTime(day, month, year, hour, min, sec); }
3740
3741 bool SameDay(const wxDateTime::Tm& tm) const
3742 {
3743 return day == tm.mday && month == tm.mon && year == tm.year;
3744 }
3745
3746 wxString Format() const
3747 {
3748 wxString s;
3749 s.Printf("%02d:%02d:%02d %10s %02d, %4d%s",
3750 hour, min, sec,
3751 wxDateTime::GetMonthName(month).c_str(),
3752 day,
3753 abs(wxDateTime::ConvertYearToBC(year)),
3754 year > 0 ? "AD" : "BC");
3755 return s;
3756 }
3757
3758 wxString FormatDate() const
3759 {
3760 wxString s;
3761 s.Printf("%02d-%s-%4d%s",
3762 day,
3763 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
3764 abs(wxDateTime::ConvertYearToBC(year)),
3765 year > 0 ? "AD" : "BC");
3766 return s;
3767 }
3768 };
3769
3770 static const Date testDates[] =
3771 {
3772 { 1, wxDateTime::Jan, 1970, 00, 00, 00, 2440587.5, wxDateTime::Thu, 0, -3600 },
3773 { 7, wxDateTime::Feb, 2036, 00, 00, 00, 2464730.5, wxDateTime::Thu, -1, -1 },
3774 { 8, wxDateTime::Feb, 2036, 00, 00, 00, 2464731.5, wxDateTime::Fri, -1, -1 },
3775 { 1, wxDateTime::Jan, 2037, 00, 00, 00, 2465059.5, wxDateTime::Thu, -1, -1 },
3776 { 1, wxDateTime::Jan, 2038, 00, 00, 00, 2465424.5, wxDateTime::Fri, -1, -1 },
3777 { 21, wxDateTime::Jan, 2222, 00, 00, 00, 2532648.5, wxDateTime::Mon, -1, -1 },
3778 { 29, wxDateTime::May, 1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
3779 { 29, wxDateTime::Feb, 1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
3780 { 1, wxDateTime::Jan, 1900, 12, 00, 00, 2415021.0, wxDateTime::Mon, -1, -1 },
3781 { 1, wxDateTime::Jan, 1900, 00, 00, 00, 2415020.5, wxDateTime::Mon, -1, -1 },
3782 { 15, wxDateTime::Oct, 1582, 00, 00, 00, 2299160.5, wxDateTime::Fri, -1, -1 },
3783 { 4, wxDateTime::Oct, 1582, 00, 00, 00, 2299149.5, wxDateTime::Mon, -1, -1 },
3784 { 1, wxDateTime::Mar, 1, 00, 00, 00, 1721484.5, wxDateTime::Thu, -1, -1 },
3785 { 1, wxDateTime::Jan, 1, 00, 00, 00, 1721425.5, wxDateTime::Mon, -1, -1 },
3786 { 31, wxDateTime::Dec, 0, 00, 00, 00, 1721424.5, wxDateTime::Sun, -1, -1 },
3787 { 1, wxDateTime::Jan, 0, 00, 00, 00, 1721059.5, wxDateTime::Sat, -1, -1 },
3788 { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri, -1, -1 },
3789 { 12, wxDateTime::Aug, -4000, 00, 00, 00, 260313.5, wxDateTime::Sat, -1, -1 },
3790 { 24, wxDateTime::Nov, -4713, 00, 00, 00, -0.5, wxDateTime::Mon, -1, -1 },
3791 };
3792
3793 // this test miscellaneous static wxDateTime functions
3794 static void TestTimeStatic()
3795 {
3796 puts("\n*** wxDateTime static methods test ***");
3797
3798 // some info about the current date
3799 int year = wxDateTime::GetCurrentYear();
3800 printf("Current year %d is %sa leap one and has %d days.\n",
3801 year,
3802 wxDateTime::IsLeapYear(year) ? "" : "not ",
3803 wxDateTime::GetNumberOfDays(year));
3804
3805 wxDateTime::Month month = wxDateTime::GetCurrentMonth();
3806 printf("Current month is '%s' ('%s') and it has %d days\n",
3807 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
3808 wxDateTime::GetMonthName(month).c_str(),
3809 wxDateTime::GetNumberOfDays(month));
3810
3811 // leap year logic
3812 static const size_t nYears = 5;
3813 static const size_t years[2][nYears] =
3814 {
3815 // first line: the years to test
3816 { 1990, 1976, 2000, 2030, 1984, },
3817
3818 // second line: TRUE if leap, FALSE otherwise
3819 { FALSE, TRUE, TRUE, FALSE, TRUE }
3820 };
3821
3822 for ( size_t n = 0; n < nYears; n++ )
3823 {
3824 int year = years[0][n];
3825 bool should = years[1][n] != 0,
3826 is = wxDateTime::IsLeapYear(year);
3827
3828 printf("Year %d is %sa leap year (%s)\n",
3829 year,
3830 is ? "" : "not ",
3831 should == is ? "ok" : "ERROR");
3832
3833 wxASSERT( should == wxDateTime::IsLeapYear(year) );
3834 }
3835 }
3836
3837 // test constructing wxDateTime objects
3838 static void TestTimeSet()
3839 {
3840 puts("\n*** wxDateTime construction test ***");
3841
3842 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
3843 {
3844 const Date& d1 = testDates[n];
3845 wxDateTime dt = d1.DT();
3846
3847 Date d2;
3848 d2.Init(dt.GetTm());
3849
3850 wxString s1 = d1.Format(),
3851 s2 = d2.Format();
3852
3853 printf("Date: %s == %s (%s)\n",
3854 s1.c_str(), s2.c_str(),
3855 s1 == s2 ? "ok" : "ERROR");
3856 }
3857 }
3858
3859 // test time zones stuff
3860 static void TestTimeZones()
3861 {
3862 puts("\n*** wxDateTime timezone test ***");
3863
3864 wxDateTime now = wxDateTime::Now();
3865
3866 printf("Current GMT time:\t%s\n", now.Format("%c", wxDateTime::GMT0).c_str());
3867 printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::GMT0).c_str());
3868 printf("Unix epoch (EST):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::EST).c_str());
3869 printf("Current time in Paris:\t%s\n", now.Format("%c", wxDateTime::CET).c_str());
3870 printf(" Moscow:\t%s\n", now.Format("%c", wxDateTime::MSK).c_str());
3871 printf(" New York:\t%s\n", now.Format("%c", wxDateTime::EST).c_str());
3872
3873 wxDateTime::Tm tm = now.GetTm();
3874 if ( wxDateTime(tm) != now )
3875 {
3876 printf("ERROR: got %s instead of %s\n",
3877 wxDateTime(tm).Format().c_str(), now.Format().c_str());
3878 }
3879 }
3880
3881 // test some minimal support for the dates outside the standard range
3882 static void TestTimeRange()
3883 {
3884 puts("\n*** wxDateTime out-of-standard-range dates test ***");
3885
3886 static const char *fmt = "%d-%b-%Y %H:%M:%S";
3887
3888 printf("Unix epoch:\t%s\n",
3889 wxDateTime(2440587.5).Format(fmt).c_str());
3890 printf("Feb 29, 0: \t%s\n",
3891 wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3892 printf("JDN 0: \t%s\n",
3893 wxDateTime(0.0).Format(fmt).c_str());
3894 printf("Jan 1, 1AD:\t%s\n",
3895 wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3896 printf("May 29, 2099:\t%s\n",
3897 wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
3898 }
3899
3900 static void TestTimeTicks()
3901 {
3902 puts("\n*** wxDateTime ticks test ***");
3903
3904 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
3905 {
3906 const Date& d = testDates[n];
3907 if ( d.ticks == -1 )
3908 continue;
3909
3910 wxDateTime dt = d.DT();
3911 long ticks = (dt.GetValue() / 1000).ToLong();
3912 printf("Ticks of %s:\t% 10ld", d.Format().c_str(), ticks);
3913 if ( ticks == d.ticks )
3914 {
3915 puts(" (ok)");
3916 }
3917 else
3918 {
3919 printf(" (ERROR: should be %ld, delta = %ld)\n",
3920 (long)d.ticks, (long)(ticks - d.ticks));
3921 }
3922
3923 dt = d.DT().ToTimezone(wxDateTime::GMT0);
3924 ticks = (dt.GetValue() / 1000).ToLong();
3925 printf("GMtks of %s:\t% 10ld", d.Format().c_str(), ticks);
3926 if ( ticks == d.gmticks )
3927 {
3928 puts(" (ok)");
3929 }
3930 else
3931 {
3932 printf(" (ERROR: should be %ld, delta = %ld)\n",
3933 (long)d.gmticks, (long)(ticks - d.gmticks));
3934 }
3935 }
3936
3937 puts("");
3938 }
3939
3940 // test conversions to JDN &c
3941 static void TestTimeJDN()
3942 {
3943 puts("\n*** wxDateTime to JDN test ***");
3944
3945 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
3946 {
3947 const Date& d = testDates[n];
3948 wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
3949 double jdn = dt.GetJulianDayNumber();
3950
3951 printf("JDN of %s is:\t% 15.6f", d.Format().c_str(), jdn);
3952 if ( jdn == d.jdn )
3953 {
3954 puts(" (ok)");
3955 }
3956 else
3957 {
3958 printf(" (ERROR: should be %f, delta = %f)\n",
3959 d.jdn, jdn - d.jdn);
3960 }
3961 }
3962 }
3963
3964 // test week days computation
3965 static void TestTimeWDays()
3966 {
3967 puts("\n*** wxDateTime weekday test ***");
3968
3969 // test GetWeekDay()
3970 size_t n;
3971 for ( n = 0; n < WXSIZEOF(testDates); n++ )
3972 {
3973 const Date& d = testDates[n];
3974 wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
3975
3976 wxDateTime::WeekDay wday = dt.GetWeekDay();
3977 printf("%s is: %s",
3978 d.Format().c_str(),
3979 wxDateTime::GetWeekDayName(wday).c_str());
3980 if ( wday == d.wday )
3981 {
3982 puts(" (ok)");
3983 }
3984 else
3985 {
3986 printf(" (ERROR: should be %s)\n",
3987 wxDateTime::GetWeekDayName(d.wday).c_str());
3988 }
3989 }
3990
3991 puts("");
3992
3993 // test SetToWeekDay()
3994 struct WeekDateTestData
3995 {
3996 Date date; // the real date (precomputed)
3997 int nWeek; // its week index in the month
3998 wxDateTime::WeekDay wday; // the weekday
3999 wxDateTime::Month month; // the month
4000 int year; // and the year
4001
4002 wxString Format() const
4003 {
4004 wxString s, which;
4005 switch ( nWeek < -1 ? -nWeek : nWeek )
4006 {
4007 case 1: which = "first"; break;
4008 case 2: which = "second"; break;
4009 case 3: which = "third"; break;
4010 case 4: which = "fourth"; break;
4011 case 5: which = "fifth"; break;
4012
4013 case -1: which = "last"; break;
4014 }
4015
4016 if ( nWeek < -1 )
4017 {
4018 which += " from end";
4019 }
4020
4021 s.Printf("The %s %s of %s in %d",
4022 which.c_str(),
4023 wxDateTime::GetWeekDayName(wday).c_str(),
4024 wxDateTime::GetMonthName(month).c_str(),
4025 year);
4026
4027 return s;
4028 }
4029 };
4030
4031 // the array data was generated by the following python program
4032 /*
4033 from DateTime import *
4034 from whrandom import *
4035 from string import *
4036
4037 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4038 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4039
4040 week = DateTimeDelta(7)
4041
4042 for n in range(20):
4043 year = randint(1900, 2100)
4044 month = randint(1, 12)
4045 day = randint(1, 28)
4046 dt = DateTime(year, month, day)
4047 wday = dt.day_of_week
4048
4049 countFromEnd = choice([-1, 1])
4050 weekNum = 0;
4051
4052 while dt.month is month:
4053 dt = dt - countFromEnd * week
4054 weekNum = weekNum + countFromEnd
4055
4056 data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
4057
4058 print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
4059 "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
4060 */
4061
4062 static const WeekDateTestData weekDatesTestData[] =
4063 {
4064 { { 20, wxDateTime::Mar, 2045 }, 3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
4065 { { 5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
4066 { { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
4067 { { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
4068 { { 4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
4069 { { 2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
4070 { { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
4071 { { 5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
4072 { { 11, wxDateTime::Aug, 1900 }, 2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
4073 { { 14, wxDateTime::Feb, 1945 }, 2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
4074 { { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
4075 { { 9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
4076 { { 20, wxDateTime::Jun, 1927 }, 3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
4077 { { 2, wxDateTime::Aug, 2000 }, 1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
4078 { { 20, wxDateTime::Apr, 2044 }, 3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
4079 { { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
4080 { { 25, wxDateTime::Jul, 2069 }, 4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
4081 { { 3, wxDateTime::Apr, 1925 }, 1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
4082 { { 21, wxDateTime::Mar, 2093 }, 3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
4083 { { 3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
4084 };
4085
4086 static const char *fmt = "%d-%b-%Y";
4087
4088 wxDateTime dt;
4089 for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
4090 {
4091 const WeekDateTestData& wd = weekDatesTestData[n];
4092
4093 dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
4094
4095 printf("%s is %s", wd.Format().c_str(), dt.Format(fmt).c_str());
4096
4097 const Date& d = wd.date;
4098 if ( d.SameDay(dt.GetTm()) )
4099 {
4100 puts(" (ok)");
4101 }
4102 else
4103 {
4104 dt.Set(d.day, d.month, d.year);
4105
4106 printf(" (ERROR: should be %s)\n", dt.Format(fmt).c_str());
4107 }
4108 }
4109 }
4110
4111 // test the computation of (ISO) week numbers
4112 static void TestTimeWNumber()
4113 {
4114 puts("\n*** wxDateTime week number test ***");
4115
4116 struct WeekNumberTestData
4117 {
4118 Date date; // the date
4119 wxDateTime::wxDateTime_t week; // the week number in the year
4120 wxDateTime::wxDateTime_t wmon; // the week number in the month
4121 wxDateTime::wxDateTime_t wmon2; // same but week starts with Sun
4122 wxDateTime::wxDateTime_t dnum; // day number in the year
4123 };
4124
4125 // data generated with the following python script:
4126 /*
4127 from DateTime import *
4128 from whrandom import *
4129 from string import *
4130
4131 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4132 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4133
4134 def GetMonthWeek(dt):
4135 weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
4136 if weekNumMonth < 0:
4137 weekNumMonth = weekNumMonth + 53
4138 return weekNumMonth
4139
4140 def GetLastSundayBefore(dt):
4141 if dt.iso_week[2] == 7:
4142 return dt
4143 else:
4144 return dt - DateTimeDelta(dt.iso_week[2])
4145
4146 for n in range(20):
4147 year = randint(1900, 2100)
4148 month = randint(1, 12)
4149 day = randint(1, 28)
4150 dt = DateTime(year, month, day)
4151 dayNum = dt.day_of_year
4152 weekNum = dt.iso_week[1]
4153 weekNumMonth = GetMonthWeek(dt)
4154
4155 weekNumMonth2 = 0
4156 dtSunday = GetLastSundayBefore(dt)
4157
4158 while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
4159 weekNumMonth2 = weekNumMonth2 + 1
4160 dtSunday = dtSunday - DateTimeDelta(7)
4161
4162 data = { 'day': rjust(`day`, 2), \
4163 'month': monthNames[month - 1], \
4164 'year': year, \
4165 'weekNum': rjust(`weekNum`, 2), \
4166 'weekNumMonth': weekNumMonth, \
4167 'weekNumMonth2': weekNumMonth2, \
4168 'dayNum': rjust(`dayNum`, 3) }
4169
4170 print " { { %(day)s, "\
4171 "wxDateTime::%(month)s, "\
4172 "%(year)d }, "\
4173 "%(weekNum)s, "\
4174 "%(weekNumMonth)s, "\
4175 "%(weekNumMonth2)s, "\
4176 "%(dayNum)s }," % data
4177
4178 */
4179 static const WeekNumberTestData weekNumberTestDates[] =
4180 {
4181 { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
4182 { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
4183 { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
4184 { { 1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
4185 { { 8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
4186 { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4, 81 },
4187 { { 7, wxDateTime::Jan, 1965 }, 1, 2, 2, 7 },
4188 { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
4189 { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
4190 { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
4191 { { 2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
4192 { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
4193 { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
4194 { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
4195 { { 3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
4196 { { 23, wxDateTime::Feb, 1940 }, 8, 4, 4, 54 },
4197 { { 2, wxDateTime::Jan, 1987 }, 1, 1, 1, 2 },
4198 { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
4199 { { 2, wxDateTime::Feb, 2063 }, 5, 1, 1, 33 },
4200 { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
4201 };
4202
4203 for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
4204 {
4205 const WeekNumberTestData& wn = weekNumberTestDates[n];
4206 const Date& d = wn.date;
4207
4208 wxDateTime dt = d.DT();
4209
4210 wxDateTime::wxDateTime_t
4211 week = dt.GetWeekOfYear(wxDateTime::Monday_First),
4212 wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
4213 wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4214 dnum = dt.GetDayOfYear();
4215
4216 printf("%s: the day number is %d",
4217 d.FormatDate().c_str(), dnum);
4218 if ( dnum == wn.dnum )
4219 {
4220 printf(" (ok)");
4221 }
4222 else
4223 {
4224 printf(" (ERROR: should be %d)", wn.dnum);
4225 }
4226
4227 printf(", week in month is %d", wmon);
4228 if ( wmon == wn.wmon )
4229 {
4230 printf(" (ok)");
4231 }
4232 else
4233 {
4234 printf(" (ERROR: should be %d)", wn.wmon);
4235 }
4236
4237 printf(" or %d", wmon2);
4238 if ( wmon2 == wn.wmon2 )
4239 {
4240 printf(" (ok)");
4241 }
4242 else
4243 {
4244 printf(" (ERROR: should be %d)", wn.wmon2);
4245 }
4246
4247 printf(", week in year is %d", week);
4248 if ( week == wn.week )
4249 {
4250 puts(" (ok)");
4251 }
4252 else
4253 {
4254 printf(" (ERROR: should be %d)\n", wn.week);
4255 }
4256 }
4257 }
4258
4259 // test DST calculations
4260 static void TestTimeDST()
4261 {
4262 puts("\n*** wxDateTime DST test ***");
4263
4264 printf("DST is%s in effect now.\n\n",
4265 wxDateTime::Now().IsDST() ? "" : " not");
4266
4267 // taken from http://www.energy.ca.gov/daylightsaving.html
4268 static const Date datesDST[2][2004 - 1900 + 1] =
4269 {
4270 {
4271 { 1, wxDateTime::Apr, 1990 },
4272 { 7, wxDateTime::Apr, 1991 },
4273 { 5, wxDateTime::Apr, 1992 },
4274 { 4, wxDateTime::Apr, 1993 },
4275 { 3, wxDateTime::Apr, 1994 },
4276 { 2, wxDateTime::Apr, 1995 },
4277 { 7, wxDateTime::Apr, 1996 },
4278 { 6, wxDateTime::Apr, 1997 },
4279 { 5, wxDateTime::Apr, 1998 },
4280 { 4, wxDateTime::Apr, 1999 },
4281 { 2, wxDateTime::Apr, 2000 },
4282 { 1, wxDateTime::Apr, 2001 },
4283 { 7, wxDateTime::Apr, 2002 },
4284 { 6, wxDateTime::Apr, 2003 },
4285 { 4, wxDateTime::Apr, 2004 },
4286 },
4287 {
4288 { 28, wxDateTime::Oct, 1990 },
4289 { 27, wxDateTime::Oct, 1991 },
4290 { 25, wxDateTime::Oct, 1992 },
4291 { 31, wxDateTime::Oct, 1993 },
4292 { 30, wxDateTime::Oct, 1994 },
4293 { 29, wxDateTime::Oct, 1995 },
4294 { 27, wxDateTime::Oct, 1996 },
4295 { 26, wxDateTime::Oct, 1997 },
4296 { 25, wxDateTime::Oct, 1998 },
4297 { 31, wxDateTime::Oct, 1999 },
4298 { 29, wxDateTime::Oct, 2000 },
4299 { 28, wxDateTime::Oct, 2001 },
4300 { 27, wxDateTime::Oct, 2002 },
4301 { 26, wxDateTime::Oct, 2003 },
4302 { 31, wxDateTime::Oct, 2004 },
4303 }
4304 };
4305
4306 int year;
4307 for ( year = 1990; year < 2005; year++ )
4308 {
4309 wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
4310 dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
4311
4312 printf("DST period in the US for year %d: from %s to %s",
4313 year, dtBegin.Format().c_str(), dtEnd.Format().c_str());
4314
4315 size_t n = year - 1990;
4316 const Date& dBegin = datesDST[0][n];
4317 const Date& dEnd = datesDST[1][n];
4318
4319 if ( dBegin.SameDay(dtBegin.GetTm()) && dEnd.SameDay(dtEnd.GetTm()) )
4320 {
4321 puts(" (ok)");
4322 }
4323 else
4324 {
4325 printf(" (ERROR: should be %s %d to %s %d)\n",
4326 wxDateTime::GetMonthName(dBegin.month).c_str(), dBegin.day,
4327 wxDateTime::GetMonthName(dEnd.month).c_str(), dEnd.day);
4328 }
4329 }
4330
4331 puts("");
4332
4333 for ( year = 1990; year < 2005; year++ )
4334 {
4335 printf("DST period in Europe for year %d: from %s to %s\n",
4336 year,
4337 wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
4338 wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
4339 }
4340 }
4341
4342 // test wxDateTime -> text conversion
4343 static void TestTimeFormat()
4344 {
4345 puts("\n*** wxDateTime formatting test ***");
4346
4347 // some information may be lost during conversion, so store what kind
4348 // of info should we recover after a round trip
4349 enum CompareKind
4350 {
4351 CompareNone, // don't try comparing
4352 CompareBoth, // dates and times should be identical
4353 CompareDate, // dates only
4354 CompareTime // time only
4355 };
4356
4357 static const struct
4358 {
4359 CompareKind compareKind;
4360 const char *format;
4361 } formatTestFormats[] =
4362 {
4363 { CompareBoth, "---> %c" },
4364 { CompareDate, "Date is %A, %d of %B, in year %Y" },
4365 { CompareBoth, "Date is %x, time is %X" },
4366 { CompareTime, "Time is %H:%M:%S or %I:%M:%S %p" },
4367 { CompareNone, "The day of year: %j, the week of year: %W" },
4368 { CompareDate, "ISO date without separators: %4Y%2m%2d" },
4369 };
4370
4371 static const Date formatTestDates[] =
4372 {
4373 { 29, wxDateTime::May, 1976, 18, 30, 00 },
4374 { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
4375 #if 0
4376 // this test can't work for other centuries because it uses two digit
4377 // years in formats, so don't even try it
4378 { 29, wxDateTime::May, 2076, 18, 30, 00 },
4379 { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
4380 { 01, wxDateTime::Jan, -52, 03, 16, 47 },
4381 #endif
4382 };
4383
4384 // an extra test (as it doesn't depend on date, don't do it in the loop)
4385 printf("%s\n", wxDateTime::Now().Format("Our timezone is %Z").c_str());
4386
4387 for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
4388 {
4389 puts("");
4390
4391 wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
4392 for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
4393 {
4394 wxString s = dt.Format(formatTestFormats[n].format);
4395 printf("%s", s.c_str());
4396
4397 // what can we recover?
4398 int kind = formatTestFormats[n].compareKind;
4399
4400 // convert back
4401 wxDateTime dt2;
4402 const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
4403 if ( !result )
4404 {
4405 // converion failed - should it have?
4406 if ( kind == CompareNone )
4407 puts(" (ok)");
4408 else
4409 puts(" (ERROR: conversion back failed)");
4410 }
4411 else if ( *result )
4412 {
4413 // should have parsed the entire string
4414 puts(" (ERROR: conversion back stopped too soon)");
4415 }
4416 else
4417 {
4418 bool equal = FALSE; // suppress compilaer warning
4419 switch ( kind )
4420 {
4421 case CompareBoth:
4422 equal = dt2 == dt;
4423 break;
4424
4425 case CompareDate:
4426 equal = dt.IsSameDate(dt2);
4427 break;
4428
4429 case CompareTime:
4430 equal = dt.IsSameTime(dt2);
4431 break;
4432 }
4433
4434 if ( !equal )
4435 {
4436 printf(" (ERROR: got back '%s' instead of '%s')\n",
4437 dt2.Format().c_str(), dt.Format().c_str());
4438 }
4439 else
4440 {
4441 puts(" (ok)");
4442 }
4443 }
4444 }
4445 }
4446 }
4447
4448 // test text -> wxDateTime conversion
4449 static void TestTimeParse()
4450 {
4451 puts("\n*** wxDateTime parse test ***");
4452
4453 struct ParseTestData
4454 {
4455 const char *format;
4456 Date date;
4457 bool good;
4458 };
4459
4460 static const ParseTestData parseTestDates[] =
4461 {
4462 { "Sat, 18 Dec 1999 00:46:40 +0100", { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, TRUE },
4463 { "Wed, 1 Dec 1999 05:17:20 +0300", { 1, wxDateTime::Dec, 1999, 03, 17, 20 }, TRUE },
4464 };
4465
4466 for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
4467 {
4468 const char *format = parseTestDates[n].format;
4469
4470 printf("%s => ", format);
4471
4472 wxDateTime dt;
4473 if ( dt.ParseRfc822Date(format) )
4474 {
4475 printf("%s ", dt.Format().c_str());
4476
4477 if ( parseTestDates[n].good )
4478 {
4479 wxDateTime dtReal = parseTestDates[n].date.DT();
4480 if ( dt == dtReal )
4481 {
4482 puts("(ok)");
4483 }
4484 else
4485 {
4486 printf("(ERROR: should be %s)\n", dtReal.Format().c_str());
4487 }
4488 }
4489 else
4490 {
4491 puts("(ERROR: bad format)");
4492 }
4493 }
4494 else
4495 {
4496 printf("bad format (%s)\n",
4497 parseTestDates[n].good ? "ERROR" : "ok");
4498 }
4499 }
4500 }
4501
4502 static void TestDateTimeInteractive()
4503 {
4504 puts("\n*** interactive wxDateTime tests ***");
4505
4506 char buf[128];
4507
4508 for ( ;; )
4509 {
4510 printf("Enter a date: ");
4511 if ( !fgets(buf, WXSIZEOF(buf), stdin) )
4512 break;
4513
4514 // kill the last '\n'
4515 buf[strlen(buf) - 1] = 0;
4516
4517 wxDateTime dt;
4518 const char *p = dt.ParseDate(buf);
4519 if ( !p )
4520 {
4521 printf("ERROR: failed to parse the date '%s'.\n", buf);
4522
4523 continue;
4524 }
4525 else if ( *p )
4526 {
4527 printf("WARNING: parsed only first %u characters.\n", p - buf);
4528 }
4529
4530 printf("%s: day %u, week of month %u/%u, week of year %u\n",
4531 dt.Format("%b %d, %Y").c_str(),
4532 dt.GetDayOfYear(),
4533 dt.GetWeekOfMonth(wxDateTime::Monday_First),
4534 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4535 dt.GetWeekOfYear(wxDateTime::Monday_First));
4536 }
4537
4538 puts("\n*** done ***");
4539 }
4540
4541 static void TestTimeMS()
4542 {
4543 puts("*** testing millisecond-resolution support in wxDateTime ***");
4544
4545 wxDateTime dt1 = wxDateTime::Now(),
4546 dt2 = wxDateTime::UNow();
4547
4548 printf("Now = %s\n", dt1.Format("%H:%M:%S:%l").c_str());
4549 printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());
4550 printf("Dummy loop: ");
4551 for ( int i = 0; i < 6000; i++ )
4552 {
4553 //for ( int j = 0; j < 10; j++ )
4554 {
4555 wxString s;
4556 s.Printf("%g", sqrt(i));
4557 }
4558
4559 if ( !(i % 100) )
4560 putchar('.');
4561 }
4562 puts(", done");
4563
4564 dt1 = dt2;
4565 dt2 = wxDateTime::UNow();
4566 printf("UNow = %s\n", dt2.Format("%H:%M:%S:%l").c_str());
4567
4568 printf("Loop executed in %s ms\n", (dt2 - dt1).Format("%l").c_str());
4569
4570 puts("\n*** done ***");
4571 }
4572
4573 static void TestTimeArithmetics()
4574 {
4575 puts("\n*** testing arithmetic operations on wxDateTime ***");
4576
4577 static const struct ArithmData
4578 {
4579 ArithmData(const wxDateSpan& sp, const char *nam)
4580 : span(sp), name(nam) { }
4581
4582 wxDateSpan span;
4583 const char *name;
4584 } testArithmData[] =
4585 {
4586 ArithmData(wxDateSpan::Day(), "day"),
4587 ArithmData(wxDateSpan::Week(), "week"),
4588 ArithmData(wxDateSpan::Month(), "month"),
4589 ArithmData(wxDateSpan::Year(), "year"),
4590 ArithmData(wxDateSpan(1, 2, 3, 4), "year, 2 months, 3 weeks, 4 days"),
4591 };
4592
4593 wxDateTime dt(29, wxDateTime::Dec, 1999), dt1, dt2;
4594
4595 for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
4596 {
4597 wxDateSpan span = testArithmData[n].span;
4598 dt1 = dt + span;
4599 dt2 = dt - span;
4600
4601 const char *name = testArithmData[n].name;
4602 printf("%s + %s = %s, %s - %s = %s\n",
4603 dt.FormatISODate().c_str(), name, dt1.FormatISODate().c_str(),
4604 dt.FormatISODate().c_str(), name, dt2.FormatISODate().c_str());
4605
4606 printf("Going back: %s", (dt1 - span).FormatISODate().c_str());
4607 if ( dt1 - span == dt )
4608 {
4609 puts(" (ok)");
4610 }
4611 else
4612 {
4613 printf(" (ERROR: should be %s)\n", dt.FormatISODate().c_str());
4614 }
4615
4616 printf("Going forward: %s", (dt2 + span).FormatISODate().c_str());
4617 if ( dt2 + span == dt )
4618 {
4619 puts(" (ok)");
4620 }
4621 else
4622 {
4623 printf(" (ERROR: should be %s)\n", dt.FormatISODate().c_str());
4624 }
4625
4626 printf("Double increment: %s", (dt2 + 2*span).FormatISODate().c_str());
4627 if ( dt2 + 2*span == dt1 )
4628 {
4629 puts(" (ok)");
4630 }
4631 else
4632 {
4633 printf(" (ERROR: should be %s)\n", dt2.FormatISODate().c_str());
4634 }
4635
4636 puts("");
4637 }
4638 }
4639
4640 static void TestTimeHolidays()
4641 {
4642 puts("\n*** testing wxDateTimeHolidayAuthority ***\n");
4643
4644 wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
4645 wxDateTime dtStart(1, tm.mon, tm.year),
4646 dtEnd = dtStart.GetLastMonthDay();
4647
4648 wxDateTimeArray hol;
4649 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
4650
4651 const wxChar *format = "%d-%b-%Y (%a)";
4652
4653 printf("All holidays between %s and %s:\n",
4654 dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
4655
4656 size_t count = hol.GetCount();
4657 for ( size_t n = 0; n < count; n++ )
4658 {
4659 printf("\t%s\n", hol[n].Format(format).c_str());
4660 }
4661
4662 puts("");
4663 }
4664
4665 static void TestTimeZoneBug()
4666 {
4667 puts("\n*** testing for DST/timezone bug ***\n");
4668
4669 wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
4670 for ( int i = 0; i < 31; i++ )
4671 {
4672 printf("Date %s: week day %s.\n",
4673 date.Format(_T("%d-%m-%Y")).c_str(),
4674 date.GetWeekDayName(date.GetWeekDay()).c_str());
4675
4676 date += wxDateSpan::Day();
4677 }
4678
4679 puts("");
4680 }
4681
4682 static void TestTimeSpanFormat()
4683 {
4684 puts("\n*** wxTimeSpan tests ***");
4685
4686 static const char *formats[] =
4687 {
4688 _T("(default) %H:%M:%S"),
4689 _T("%E weeks and %D days"),
4690 _T("%l milliseconds"),
4691 _T("(with ms) %H:%M:%S:%l"),
4692 _T("100%% of minutes is %M"), // test "%%"
4693 _T("%D days and %H hours"),
4694 _T("or also %S seconds"),
4695 };
4696
4697 wxTimeSpan ts1(1, 2, 3, 4),
4698 ts2(111, 222, 333);
4699 for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
4700 {
4701 printf("ts1 = %s\tts2 = %s\n",
4702 ts1.Format(formats[n]).c_str(),
4703 ts2.Format(formats[n]).c_str());
4704 }
4705
4706 puts("");
4707 }
4708
4709 #if 0
4710
4711 // test compatibility with the old wxDate/wxTime classes
4712 static void TestTimeCompatibility()
4713 {
4714 puts("\n*** wxDateTime compatibility test ***");
4715
4716 printf("wxDate for JDN 0: %s\n", wxDate(0l).FormatDate().c_str());
4717 printf("wxDate for MJD 0: %s\n", wxDate(2400000).FormatDate().c_str());
4718
4719 double jdnNow = wxDateTime::Now().GetJDN();
4720 long jdnMidnight = (long)(jdnNow - 0.5);
4721 printf("wxDate for today: %s\n", wxDate(jdnMidnight).FormatDate().c_str());
4722
4723 jdnMidnight = wxDate().Set().GetJulianDate();
4724 printf("wxDateTime for today: %s\n",
4725 wxDateTime((double)(jdnMidnight + 0.5)).Format("%c", wxDateTime::GMT0).c_str());
4726
4727 int flags = wxEUROPEAN;//wxFULL;
4728 wxDate date;
4729 date.Set();
4730 printf("Today is %s\n", date.FormatDate(flags).c_str());
4731 for ( int n = 0; n < 7; n++ )
4732 {
4733 printf("Previous %s is %s\n",
4734 wxDateTime::GetWeekDayName((wxDateTime::WeekDay)n),
4735 date.Previous(n + 1).FormatDate(flags).c_str());
4736 }
4737 }
4738
4739 #endif // 0
4740
4741 #endif // TEST_DATETIME
4742
4743 // ----------------------------------------------------------------------------
4744 // threads
4745 // ----------------------------------------------------------------------------
4746
4747 #ifdef TEST_THREADS
4748
4749 #include "wx/thread.h"
4750
4751 static size_t gs_counter = (size_t)-1;
4752 static wxCriticalSection gs_critsect;
4753 static wxSemaphore gs_cond;
4754
4755 class MyJoinableThread : public wxThread
4756 {
4757 public:
4758 MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
4759 { m_n = n; Create(); }
4760
4761 // thread execution starts here
4762 virtual ExitCode Entry();
4763
4764 private:
4765 size_t m_n;
4766 };
4767
4768 wxThread::ExitCode MyJoinableThread::Entry()
4769 {
4770 unsigned long res = 1;
4771 for ( size_t n = 1; n < m_n; n++ )
4772 {
4773 res *= n;
4774
4775 // it's a loooong calculation :-)
4776 Sleep(100);
4777 }
4778
4779 return (ExitCode)res;
4780 }
4781
4782 class MyDetachedThread : public wxThread
4783 {
4784 public:
4785 MyDetachedThread(size_t n, char ch)
4786 {
4787 m_n = n;
4788 m_ch = ch;
4789 m_cancelled = FALSE;
4790
4791 Create();
4792 }
4793
4794 // thread execution starts here
4795 virtual ExitCode Entry();
4796
4797 // and stops here
4798 virtual void OnExit();
4799
4800 private:
4801 size_t m_n; // number of characters to write
4802 char m_ch; // character to write
4803
4804 bool m_cancelled; // FALSE if we exit normally
4805 };
4806
4807 wxThread::ExitCode MyDetachedThread::Entry()
4808 {
4809 {
4810 wxCriticalSectionLocker lock(gs_critsect);
4811 if ( gs_counter == (size_t)-1 )
4812 gs_counter = 1;
4813 else
4814 gs_counter++;
4815 }
4816
4817 for ( size_t n = 0; n < m_n; n++ )
4818 {
4819 if ( TestDestroy() )
4820 {
4821 m_cancelled = TRUE;
4822
4823 break;
4824 }
4825
4826 putchar(m_ch);
4827 fflush(stdout);
4828
4829 wxThread::Sleep(100);
4830 }
4831
4832 return 0;
4833 }
4834
4835 void MyDetachedThread::OnExit()
4836 {
4837 wxLogTrace("thread", "Thread %ld is in OnExit", GetId());
4838
4839 wxCriticalSectionLocker lock(gs_critsect);
4840 if ( !--gs_counter && !m_cancelled )
4841 gs_cond.Post();
4842 }
4843
4844 static void TestDetachedThreads()
4845 {
4846 puts("\n*** Testing detached threads ***");
4847
4848 static const size_t nThreads = 3;
4849 MyDetachedThread *threads[nThreads];
4850 size_t n;
4851 for ( n = 0; n < nThreads; n++ )
4852 {
4853 threads[n] = new MyDetachedThread(10, 'A' + n);
4854 }
4855
4856 threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
4857 threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
4858
4859 for ( n = 0; n < nThreads; n++ )
4860 {
4861 threads[n]->Run();
4862 }
4863
4864 // wait until all threads terminate
4865 gs_cond.Wait();
4866
4867 puts("");
4868 }
4869
4870 static void TestJoinableThreads()
4871 {
4872 puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
4873
4874 // calc 10! in the background
4875 MyJoinableThread thread(10);
4876 thread.Run();
4877
4878 printf("\nThread terminated with exit code %lu.\n",
4879 (unsigned long)thread.Wait());
4880 }
4881
4882 static void TestThreadSuspend()
4883 {
4884 puts("\n*** Testing thread suspend/resume functions ***");
4885
4886 MyDetachedThread *thread = new MyDetachedThread(15, 'X');
4887
4888 thread->Run();
4889
4890 // this is for this demo only, in a real life program we'd use another
4891 // condition variable which would be signaled from wxThread::Entry() to
4892 // tell us that the thread really started running - but here just wait a
4893 // bit and hope that it will be enough (the problem is, of course, that
4894 // the thread might still not run when we call Pause() which will result
4895 // in an error)
4896 wxThread::Sleep(300);
4897
4898 for ( size_t n = 0; n < 3; n++ )
4899 {
4900 thread->Pause();
4901
4902 puts("\nThread suspended");
4903 if ( n > 0 )
4904 {
4905 // don't sleep but resume immediately the first time
4906 wxThread::Sleep(300);
4907 }
4908 puts("Going to resume the thread");
4909
4910 thread->Resume();
4911 }
4912
4913 puts("Waiting until it terminates now");
4914
4915 // wait until the thread terminates
4916 gs_cond.Wait();
4917
4918 puts("");
4919 }
4920
4921 static void TestThreadDelete()
4922 {
4923 // As above, using Sleep() is only for testing here - we must use some
4924 // synchronisation object instead to ensure that the thread is still
4925 // running when we delete it - deleting a detached thread which already
4926 // terminated will lead to a crash!
4927
4928 puts("\n*** Testing thread delete function ***");
4929
4930 MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
4931
4932 thread0->Delete();
4933
4934 puts("\nDeleted a thread which didn't start to run yet.");
4935
4936 MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
4937
4938 thread1->Run();
4939
4940 wxThread::Sleep(300);
4941
4942 thread1->Delete();
4943
4944 puts("\nDeleted a running thread.");
4945
4946 MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
4947
4948 thread2->Run();
4949
4950 wxThread::Sleep(300);
4951
4952 thread2->Pause();
4953
4954 thread2->Delete();
4955
4956 puts("\nDeleted a sleeping thread.");
4957
4958 MyJoinableThread thread3(20);
4959 thread3.Run();
4960
4961 thread3.Delete();
4962
4963 puts("\nDeleted a joinable thread.");
4964
4965 MyJoinableThread thread4(2);
4966 thread4.Run();
4967
4968 wxThread::Sleep(300);
4969
4970 thread4.Delete();
4971
4972 puts("\nDeleted a joinable thread which already terminated.");
4973
4974 puts("");
4975 }
4976
4977 class MyWaitingThread : public wxThread
4978 {
4979 public:
4980 MyWaitingThread( wxMutex *mutex, wxCondition *condition )
4981 {
4982 m_mutex = mutex;
4983 m_condition = condition;
4984
4985 Create();
4986 }
4987
4988 virtual ExitCode Entry()
4989 {
4990 printf("Thread %lu has started running.\n", GetId());
4991 fflush(stdout);
4992
4993 gs_cond.Post();
4994
4995 printf("Thread %lu starts to wait...\n", GetId());
4996 fflush(stdout);
4997
4998 m_mutex->Lock();
4999 m_condition->Wait();
5000 m_mutex->Unlock();
5001
5002 printf("Thread %lu finished to wait, exiting.\n", GetId());
5003 fflush(stdout);
5004
5005 return 0;
5006 }
5007
5008 private:
5009 wxMutex *m_mutex;
5010 wxCondition *m_condition;
5011 };
5012
5013 static void TestThreadConditions()
5014 {
5015 wxMutex mutex;
5016 wxCondition condition(mutex);
5017
5018 // otherwise its difficult to understand which log messages pertain to
5019 // which condition
5020 //wxLogTrace("thread", "Local condition var is %08x, gs_cond = %08x",
5021 // condition.GetId(), gs_cond.GetId());
5022
5023 // create and launch threads
5024 MyWaitingThread *threads[10];
5025
5026 size_t n;
5027 for ( n = 0; n < WXSIZEOF(threads); n++ )
5028 {
5029 threads[n] = new MyWaitingThread( &mutex, &condition );
5030 }
5031
5032 for ( n = 0; n < WXSIZEOF(threads); n++ )
5033 {
5034 threads[n]->Run();
5035 }
5036
5037 // wait until all threads run
5038 puts("Main thread is waiting for the other threads to start");
5039 fflush(stdout);
5040
5041 size_t nRunning = 0;
5042 while ( nRunning < WXSIZEOF(threads) )
5043 {
5044 gs_cond.Wait();
5045
5046 nRunning++;
5047
5048 printf("Main thread: %u already running\n", nRunning);
5049 fflush(stdout);
5050 }
5051
5052 puts("Main thread: all threads started up.");
5053 fflush(stdout);
5054
5055 wxThread::Sleep(500);
5056
5057 #if 1
5058 // now wake one of them up
5059 printf("Main thread: about to signal the condition.\n");
5060 fflush(stdout);
5061 condition.Signal();
5062 #endif
5063
5064 wxThread::Sleep(200);
5065
5066 // wake all the (remaining) threads up, so that they can exit
5067 printf("Main thread: about to broadcast the condition.\n");
5068 fflush(stdout);
5069 condition.Broadcast();
5070
5071 // give them time to terminate (dirty!)
5072 wxThread::Sleep(500);
5073 }
5074
5075 #include "wx/utils.h"
5076
5077 class MyExecThread : public wxThread
5078 {
5079 public:
5080 MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
5081 m_command(command)
5082 {
5083 Create();
5084 }
5085
5086 virtual ExitCode Entry()
5087 {
5088 return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
5089 }
5090
5091 private:
5092 wxString m_command;
5093 };
5094
5095 static void TestThreadExec()
5096 {
5097 wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
5098
5099 MyExecThread thread(_T("true"));
5100 thread.Run();
5101
5102 wxPrintf(_T("Main program exit code: %ld.\n"),
5103 wxExecute(_T("false"), wxEXEC_SYNC));
5104
5105 wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
5106 }
5107
5108 // semaphore tests
5109 #include "wx/datetime.h"
5110
5111 class MySemaphoreThread : public wxThread
5112 {
5113 public:
5114 MySemaphoreThread(int i, wxSemaphore *sem)
5115 : wxThread(wxTHREAD_JOINABLE),
5116 m_sem(sem),
5117 m_i(i)
5118 {
5119 Create();
5120 }
5121
5122 virtual ExitCode Entry()
5123 {
5124 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
5125 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5126
5127 m_sem->Wait();
5128
5129 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
5130 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5131
5132 Sleep(1000);
5133
5134 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
5135 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5136
5137 m_sem->Post();
5138
5139 return 0;
5140 }
5141
5142 private:
5143 wxSemaphore *m_sem;
5144 int m_i;
5145 };
5146
5147 WX_DEFINE_ARRAY(wxThread *, ArrayThreads);
5148
5149 static void TestSemaphore()
5150 {
5151 wxPuts(_T("*** Testing wxSemaphore class. ***"));
5152
5153 static const int SEM_LIMIT = 3;
5154
5155 wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
5156 ArrayThreads threads;
5157
5158 for ( int i = 0; i < 3*SEM_LIMIT; i++ )
5159 {
5160 threads.Add(new MySemaphoreThread(i, &sem));
5161 threads.Last()->Run();
5162 }
5163
5164 for ( size_t n = 0; n < threads.GetCount(); n++ )
5165 {
5166 threads[n]->Wait();
5167 delete threads[n];
5168 }
5169 }
5170
5171 #endif // TEST_THREADS
5172
5173 // ----------------------------------------------------------------------------
5174 // arrays
5175 // ----------------------------------------------------------------------------
5176
5177 #ifdef TEST_ARRAYS
5178
5179 #include "wx/dynarray.h"
5180
5181 typedef unsigned short ushort;
5182
5183 #define DefineCompare(name, T) \
5184 \
5185 int wxCMPFUNC_CONV name ## CompareValues(T first, T second) \
5186 { \
5187 return first - second; \
5188 } \
5189 \
5190 int wxCMPFUNC_CONV name ## Compare(T* first, T* second) \
5191 { \
5192 return *first - *second; \
5193 } \
5194 \
5195 int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second) \
5196 { \
5197 return *second - *first; \
5198 } \
5199
5200 DefineCompare(UShort, ushort);
5201 DefineCompare(Int, int);
5202
5203 // test compilation of all macros
5204 WX_DEFINE_ARRAY_SHORT(ushort, wxArrayUShort);
5205 WX_DEFINE_SORTED_ARRAY_SHORT(ushort, wxSortedArrayUShortNoCmp);
5206 WX_DEFINE_SORTED_ARRAY_CMP_SHORT(ushort, UShortCompareValues, wxSortedArrayUShort);
5207 WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt);
5208
5209 WX_DECLARE_OBJARRAY(Bar, ArrayBars);
5210 #include "wx/arrimpl.cpp"
5211 WX_DEFINE_OBJARRAY(ArrayBars);
5212
5213 static void PrintArray(const char* name, const wxArrayString& array)
5214 {
5215 printf("Dump of the array '%s'\n", name);
5216
5217 size_t nCount = array.GetCount();
5218 for ( size_t n = 0; n < nCount; n++ )
5219 {
5220 printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
5221 }
5222 }
5223
5224 int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
5225 const wxString& second)
5226 {
5227 return first.length() - second.length();
5228 }
5229
5230 #define TestArrayOf(name) \
5231 \
5232 static void PrintArray(const char* name, const wxSortedArray##name & array) \
5233 { \
5234 printf("Dump of the array '%s'\n", name); \
5235 \
5236 size_t nCount = array.GetCount(); \
5237 for ( size_t n = 0; n < nCount; n++ ) \
5238 { \
5239 printf("\t%s[%u] = %d\n", name, n, array[n]); \
5240 } \
5241 } \
5242 \
5243 static void PrintArray(const char* name, const wxArray##name & array) \
5244 { \
5245 printf("Dump of the array '%s'\n", name); \
5246 \
5247 size_t nCount = array.GetCount(); \
5248 for ( size_t n = 0; n < nCount; n++ ) \
5249 { \
5250 printf("\t%s[%u] = %d\n", name, n, array[n]); \
5251 } \
5252 } \
5253 \
5254 static void TestArrayOf ## name ## s() \
5255 { \
5256 printf("*** Testing wxArray%s ***\n", #name); \
5257 \
5258 wxArray##name a; \
5259 a.Add(1); \
5260 a.Add(17,2); \
5261 a.Add(5,3); \
5262 a.Add(3,4); \
5263 \
5264 puts("Initially:"); \
5265 PrintArray("a", a); \
5266 \
5267 puts("After sort:"); \
5268 a.Sort(name ## Compare); \
5269 PrintArray("a", a); \
5270 \
5271 puts("After reverse sort:"); \
5272 a.Sort(name ## RevCompare); \
5273 PrintArray("a", a); \
5274 \
5275 wxSortedArray##name b; \
5276 b.Add(1); \
5277 b.Add(17); \
5278 b.Add(5); \
5279 b.Add(3); \
5280 \
5281 puts("Sorted array initially:"); \
5282 PrintArray("b", b); \
5283 }
5284
5285 TestArrayOf(UShort);
5286 TestArrayOf(Int);
5287
5288 static void TestArrayOfObjects()
5289 {
5290 puts("*** Testing wxObjArray ***\n");
5291
5292 {
5293 ArrayBars bars;
5294 Bar bar("second bar (two copies!)");
5295
5296 printf("Initially: %u objects in the array, %u objects total.\n",
5297 bars.GetCount(), Bar::GetNumber());
5298
5299 bars.Add(new Bar("first bar"));
5300 bars.Add(bar,2);
5301
5302 printf("Now: %u objects in the array, %u objects total.\n",
5303 bars.GetCount(), Bar::GetNumber());
5304
5305 bars.RemoveAt(1, bars.GetCount() - 1);
5306
5307 printf("After removing all but first element: %u objects in the "
5308 "array, %u objects total.\n",
5309 bars.GetCount(), Bar::GetNumber());
5310
5311 bars.Empty();
5312
5313 printf("After Empty(): %u objects in the array, %u objects total.\n",
5314 bars.GetCount(), Bar::GetNumber());
5315 }
5316
5317 printf("Finally: no more objects in the array, %u objects total.\n",
5318 Bar::GetNumber());
5319 }
5320
5321 #endif // TEST_ARRAYS
5322
5323 // ----------------------------------------------------------------------------
5324 // strings
5325 // ----------------------------------------------------------------------------
5326
5327 #ifdef TEST_STRINGS
5328
5329 #include "wx/timer.h"
5330 #include "wx/tokenzr.h"
5331
5332 static void TestStringConstruction()
5333 {
5334 puts("*** Testing wxString constructores ***");
5335
5336 #define TEST_CTOR(args, res) \
5337 { \
5338 wxString s args ; \
5339 printf("wxString%s = %s ", #args, s.c_str()); \
5340 if ( s == res ) \
5341 { \
5342 puts("(ok)"); \
5343 } \
5344 else \
5345 { \
5346 printf("(ERROR: should be %s)\n", res); \
5347 } \
5348 }
5349
5350 TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
5351 TEST_CTOR((_T("Hello"), 4), _T("Hell"));
5352 TEST_CTOR((_T("Hello"), 5), _T("Hello"));
5353 // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
5354
5355 static const wxChar *s = _T("?really!");
5356 const wxChar *start = wxStrchr(s, _T('r'));
5357 const wxChar *end = wxStrchr(s, _T('!'));
5358 TEST_CTOR((start, end), _T("really"));
5359
5360 puts("");
5361 }
5362
5363 static void TestString()
5364 {
5365 wxStopWatch sw;
5366
5367 wxString a, b, c;
5368
5369 a.reserve (128);
5370 b.reserve (128);
5371 c.reserve (128);
5372
5373 for (int i = 0; i < 1000000; ++i)
5374 {
5375 a = "Hello";
5376 b = " world";
5377 c = "! How'ya doin'?";
5378 a += b;
5379 a += c;
5380 c = "Hello world! What's up?";
5381 if (c != a)
5382 c = "Doh!";
5383 }
5384
5385 printf ("TestString elapsed time: %ld\n", sw.Time());
5386 }
5387
5388 static void TestPChar()
5389 {
5390 wxStopWatch sw;
5391
5392 char a [128];
5393 char b [128];
5394 char c [128];
5395
5396 for (int i = 0; i < 1000000; ++i)
5397 {
5398 strcpy (a, "Hello");
5399 strcpy (b, " world");
5400 strcpy (c, "! How'ya doin'?");
5401 strcat (a, b);
5402 strcat (a, c);
5403 strcpy (c, "Hello world! What's up?");
5404 if (strcmp (c, a) == 0)
5405 strcpy (c, "Doh!");
5406 }
5407
5408 printf ("TestPChar elapsed time: %ld\n", sw.Time());
5409 }
5410
5411 static void TestStringSub()
5412 {
5413 wxString s("Hello, world!");
5414
5415 puts("*** Testing wxString substring extraction ***");
5416
5417 printf("String = '%s'\n", s.c_str());
5418 printf("Left(5) = '%s'\n", s.Left(5).c_str());
5419 printf("Right(6) = '%s'\n", s.Right(6).c_str());
5420 printf("Mid(3, 5) = '%s'\n", s(3, 5).c_str());
5421 printf("Mid(3) = '%s'\n", s.Mid(3).c_str());
5422 printf("substr(3, 5) = '%s'\n", s.substr(3, 5).c_str());
5423 printf("substr(3) = '%s'\n", s.substr(3).c_str());
5424
5425 static const wxChar *prefixes[] =
5426 {
5427 _T("Hello"),
5428 _T("Hello, "),
5429 _T("Hello, world!"),
5430 _T("Hello, world!!!"),
5431 _T(""),
5432 _T("Goodbye"),
5433 _T("Hi"),
5434 };
5435
5436 for ( size_t n = 0; n < WXSIZEOF(prefixes); n++ )
5437 {
5438 wxString prefix = prefixes[n], rest;
5439 bool rc = s.StartsWith(prefix, &rest);
5440 printf("StartsWith('%s') = %s", prefix.c_str(), rc ? "TRUE" : "FALSE");
5441 if ( rc )
5442 {
5443 printf(" (the rest is '%s')\n", rest.c_str());
5444 }
5445 else
5446 {
5447 putchar('\n');
5448 }
5449 }
5450
5451 puts("");
5452 }
5453
5454 static void TestStringFormat()
5455 {
5456 puts("*** Testing wxString formatting ***");
5457
5458 wxString s;
5459 s.Printf("%03d", 18);
5460
5461 printf("Number 18: %s\n", wxString::Format("%03d", 18).c_str());
5462 printf("Number 18: %s\n", s.c_str());
5463
5464 puts("");
5465 }
5466
5467 // returns "not found" for npos, value for all others
5468 static wxString PosToString(size_t res)
5469 {
5470 wxString s = res == wxString::npos ? wxString(_T("not found"))
5471 : wxString::Format(_T("%u"), res);
5472 return s;
5473 }
5474
5475 static void TestStringFind()
5476 {
5477 puts("*** Testing wxString find() functions ***");
5478
5479 static const wxChar *strToFind = _T("ell");
5480 static const struct StringFindTest
5481 {
5482 const wxChar *str;
5483 size_t start,
5484 result; // of searching "ell" in str
5485 } findTestData[] =
5486 {
5487 { _T("Well, hello world"), 0, 1 },
5488 { _T("Well, hello world"), 6, 7 },
5489 { _T("Well, hello world"), 9, wxString::npos },
5490 };
5491
5492 for ( size_t n = 0; n < WXSIZEOF(findTestData); n++ )
5493 {
5494 const StringFindTest& ft = findTestData[n];
5495 size_t res = wxString(ft.str).find(strToFind, ft.start);
5496
5497 printf(_T("Index of '%s' in '%s' starting from %u is %s "),
5498 strToFind, ft.str, ft.start, PosToString(res).c_str());
5499
5500 size_t resTrue = ft.result;
5501 if ( res == resTrue )
5502 {
5503 puts(_T("(ok)"));
5504 }
5505 else
5506 {
5507 printf(_T("(ERROR: should be %s)\n"),
5508 PosToString(resTrue).c_str());
5509 }
5510 }
5511
5512 puts("");
5513 }
5514
5515 static void TestStringTokenizer()
5516 {
5517 puts("*** Testing wxStringTokenizer ***");
5518
5519 static const wxChar *modeNames[] =
5520 {
5521 _T("default"),
5522 _T("return empty"),
5523 _T("return all empty"),
5524 _T("with delims"),
5525 _T("like strtok"),
5526 };
5527
5528 static const struct StringTokenizerTest
5529 {
5530 const wxChar *str; // string to tokenize
5531 const wxChar *delims; // delimiters to use
5532 size_t count; // count of token
5533 wxStringTokenizerMode mode; // how should we tokenize it
5534 } tokenizerTestData[] =
5535 {
5536 { _T(""), _T(" "), 0 },
5537 { _T("Hello, world"), _T(" "), 2 },
5538 { _T("Hello, world "), _T(" "), 2 },
5539 { _T("Hello, world"), _T(","), 2 },
5540 { _T("Hello, world!"), _T(",!"), 2 },
5541 { _T("Hello,, world!"), _T(",!"), 3 },
5542 { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL },
5543 { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
5544 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 4 },
5545 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY },
5546 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL },
5547 { _T("01/02/99"), _T("/-"), 3 },
5548 { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS },
5549 };
5550
5551 for ( size_t n = 0; n < WXSIZEOF(tokenizerTestData); n++ )
5552 {
5553 const StringTokenizerTest& tt = tokenizerTestData[n];
5554 wxStringTokenizer tkz(tt.str, tt.delims, tt.mode);
5555
5556 size_t count = tkz.CountTokens();
5557 printf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
5558 MakePrintable(tt.str).c_str(),
5559 count,
5560 MakePrintable(tt.delims).c_str(),
5561 modeNames[tkz.GetMode()]);
5562 if ( count == tt.count )
5563 {
5564 puts(_T("(ok)"));
5565 }
5566 else
5567 {
5568 printf(_T("(ERROR: should be %u)\n"), tt.count);
5569
5570 continue;
5571 }
5572
5573 // if we emulate strtok(), check that we do it correctly
5574 wxChar *buf, *s = NULL, *last;
5575
5576 if ( tkz.GetMode() == wxTOKEN_STRTOK )
5577 {
5578 buf = new wxChar[wxStrlen(tt.str) + 1];
5579 wxStrcpy(buf, tt.str);
5580
5581 s = wxStrtok(buf, tt.delims, &last);
5582 }
5583 else
5584 {
5585 buf = NULL;
5586 }
5587
5588 // now show the tokens themselves
5589 size_t count2 = 0;
5590 while ( tkz.HasMoreTokens() )
5591 {
5592 wxString token = tkz.GetNextToken();
5593
5594 printf(_T("\ttoken %u: '%s'"),
5595 ++count2,
5596 MakePrintable(token).c_str());
5597
5598 if ( buf )
5599 {
5600 if ( token == s )
5601 {
5602 puts(" (ok)");
5603 }
5604 else
5605 {
5606 printf(" (ERROR: should be %s)\n", s);
5607 }
5608
5609 s = wxStrtok(NULL, tt.delims, &last);
5610 }
5611 else
5612 {
5613 // nothing to compare with
5614 puts("");
5615 }
5616 }
5617
5618 if ( count2 != count )
5619 {
5620 puts(_T("\tERROR: token count mismatch"));
5621 }
5622
5623 delete [] buf;
5624 }
5625
5626 puts("");
5627 }
5628
5629 static void TestStringReplace()
5630 {
5631 puts("*** Testing wxString::replace ***");
5632
5633 static const struct StringReplaceTestData
5634 {
5635 const wxChar *original; // original test string
5636 size_t start, len; // the part to replace
5637 const wxChar *replacement; // the replacement string
5638 const wxChar *result; // and the expected result
5639 } stringReplaceTestData[] =
5640 {
5641 { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
5642 { _T("increase"), 0, 2, _T("de"), _T("decrease") },
5643 { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
5644 { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
5645 { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
5646 };
5647
5648 for ( size_t n = 0; n < WXSIZEOF(stringReplaceTestData); n++ )
5649 {
5650 const StringReplaceTestData data = stringReplaceTestData[n];
5651
5652 wxString original = data.original;
5653 original.replace(data.start, data.len, data.replacement);
5654
5655 wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
5656 data.original, data.start, data.len, data.replacement,
5657 original.c_str());
5658
5659 if ( original == data.result )
5660 {
5661 puts("(ok)");
5662 }
5663 else
5664 {
5665 wxPrintf(_T("(ERROR: should be '%s')\n"), data.result);
5666 }
5667 }
5668
5669 puts("");
5670 }
5671
5672 static void TestStringMatch()
5673 {
5674 wxPuts(_T("*** Testing wxString::Matches() ***"));
5675
5676 static const struct StringMatchTestData
5677 {
5678 const wxChar *text;
5679 const wxChar *wildcard;
5680 bool matches;
5681 } stringMatchTestData[] =
5682 {
5683 { _T("foobar"), _T("foo*"), 1 },
5684 { _T("foobar"), _T("*oo*"), 1 },
5685 { _T("foobar"), _T("*bar"), 1 },
5686 { _T("foobar"), _T("??????"), 1 },
5687 { _T("foobar"), _T("f??b*"), 1 },
5688 { _T("foobar"), _T("f?b*"), 0 },
5689 { _T("foobar"), _T("*goo*"), 0 },
5690 { _T("foobar"), _T("*foo"), 0 },
5691 { _T("foobarfoo"), _T("*foo"), 1 },
5692 { _T(""), _T("*"), 1 },
5693 { _T(""), _T("?"), 0 },
5694 };
5695
5696 for ( size_t n = 0; n < WXSIZEOF(stringMatchTestData); n++ )
5697 {
5698 const StringMatchTestData& data = stringMatchTestData[n];
5699 bool matches = wxString(data.text).Matches(data.wildcard);
5700 wxPrintf(_T("'%s' %s '%s' (%s)\n"),
5701 data.wildcard,
5702 matches ? _T("matches") : _T("doesn't match"),
5703 data.text,
5704 matches == data.matches ? _T("ok") : _T("ERROR"));
5705 }
5706
5707 wxPuts(_T(""));
5708 }
5709
5710 #endif // TEST_STRINGS
5711
5712 // ----------------------------------------------------------------------------
5713 // entry point
5714 // ----------------------------------------------------------------------------
5715
5716 #ifdef TEST_SNGLINST
5717 #include "wx/snglinst.h"
5718 #endif // TEST_SNGLINST
5719
5720 int main(int argc, char **argv)
5721 {
5722 wxApp::CheckBuildOptions(wxBuildOptions());
5723
5724 wxInitializer initializer;
5725 if ( !initializer )
5726 {
5727 fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
5728
5729 return -1;
5730 }
5731
5732 #ifdef TEST_SNGLINST
5733 wxSingleInstanceChecker checker;
5734 if ( checker.Create(_T(".wxconsole.lock")) )
5735 {
5736 if ( checker.IsAnotherRunning() )
5737 {
5738 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
5739
5740 return 1;
5741 }
5742
5743 // wait some time to give time to launch another instance
5744 wxPrintf(_T("Press \"Enter\" to continue..."));
5745 wxFgetc(stdin);
5746 }
5747 else // failed to create
5748 {
5749 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
5750 }
5751 #endif // TEST_SNGLINST
5752
5753 #ifdef TEST_CHARSET
5754 TestCharset();
5755 #endif // TEST_CHARSET
5756
5757 #ifdef TEST_CMDLINE
5758 TestCmdLineConvert();
5759
5760 #if wxUSE_CMDLINE_PARSER
5761 static const wxCmdLineEntryDesc cmdLineDesc[] =
5762 {
5763 { wxCMD_LINE_SWITCH, _T("h"), _T("help"), "show this help message",
5764 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
5765 { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
5766 { wxCMD_LINE_SWITCH, "q", "quiet", "be quiet" },
5767
5768 { wxCMD_LINE_OPTION, "o", "output", "output file" },
5769 { wxCMD_LINE_OPTION, "i", "input", "input dir" },
5770 { wxCMD_LINE_OPTION, "s", "size", "output block size",
5771 wxCMD_LINE_VAL_NUMBER },
5772 { wxCMD_LINE_OPTION, "d", "date", "output file date",
5773 wxCMD_LINE_VAL_DATE },
5774
5775 { wxCMD_LINE_PARAM, NULL, NULL, "input file",
5776 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
5777
5778 { wxCMD_LINE_NONE }
5779 };
5780
5781 wxCmdLineParser parser(cmdLineDesc, argc, argv);
5782
5783 parser.AddOption("project_name", "", "full path to project file",
5784 wxCMD_LINE_VAL_STRING,
5785 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
5786
5787 switch ( parser.Parse() )
5788 {
5789 case -1:
5790 wxLogMessage("Help was given, terminating.");
5791 break;
5792
5793 case 0:
5794 ShowCmdLine(parser);
5795 break;
5796
5797 default:
5798 wxLogMessage("Syntax error detected, aborting.");
5799 break;
5800 }
5801 #endif // wxUSE_CMDLINE_PARSER
5802
5803 #endif // TEST_CMDLINE
5804
5805 #ifdef TEST_STRINGS
5806 if ( TEST_ALL )
5807 {
5808 TestPChar();
5809 TestString();
5810 TestStringSub();
5811 TestStringConstruction();
5812 TestStringFormat();
5813 TestStringFind();
5814 TestStringTokenizer();
5815 TestStringReplace();
5816 }
5817 else
5818 {
5819 TestStringMatch();
5820 }
5821 #endif // TEST_STRINGS
5822
5823 #ifdef TEST_ARRAYS
5824 if ( TEST_ALL )
5825 {
5826 wxArrayString a1;
5827 a1.Add("tiger");
5828 a1.Add("cat");
5829 a1.Add("lion", 3);
5830 a1.Add("dog");
5831 a1.Add("human");
5832 a1.Add("ape");
5833
5834 puts("*** Initially:");
5835
5836 PrintArray("a1", a1);
5837
5838 wxArrayString a2(a1);
5839 PrintArray("a2", a2);
5840
5841 wxSortedArrayString a3(a1);
5842 PrintArray("a3", a3);
5843
5844 puts("*** After deleting three strings from a1");
5845 a1.Remove(2,3);
5846
5847 PrintArray("a1", a1);
5848 PrintArray("a2", a2);
5849 PrintArray("a3", a3);
5850
5851 puts("*** After reassigning a1 to a2 and a3");
5852 a3 = a2 = a1;
5853 PrintArray("a2", a2);
5854 PrintArray("a3", a3);
5855
5856 puts("*** After sorting a1");
5857 a1.Sort();
5858 PrintArray("a1", a1);
5859
5860 puts("*** After sorting a1 in reverse order");
5861 a1.Sort(TRUE);
5862 PrintArray("a1", a1);
5863
5864 puts("*** After sorting a1 by the string length");
5865 a1.Sort(StringLenCompare);
5866 PrintArray("a1", a1);
5867
5868 TestArrayOfObjects();
5869 TestArrayOfUShorts();
5870 }
5871
5872 TestArrayOfInts();
5873 #endif // TEST_ARRAYS
5874
5875 #ifdef TEST_DIR
5876 if ( TEST_ALL )
5877 {
5878 TestDirExists();
5879 TestDirTraverse();
5880 }
5881 TestDirEnum();
5882 #endif // TEST_DIR
5883
5884 #ifdef TEST_DLLLOADER
5885 TestDllLoad();
5886 #endif // TEST_DLLLOADER
5887
5888 #ifdef TEST_ENVIRON
5889 TestEnvironment();
5890 #endif // TEST_ENVIRON
5891
5892 #ifdef TEST_EXECUTE
5893 TestExecute();
5894 #endif // TEST_EXECUTE
5895
5896 #ifdef TEST_FILECONF
5897 TestFileConfRead();
5898 #endif // TEST_FILECONF
5899
5900 #ifdef TEST_LIST
5901 TestListCtor();
5902 #endif // TEST_LIST
5903
5904 #ifdef TEST_LOCALE
5905 TestDefaultLang();
5906 #endif // TEST_LOCALE
5907
5908 #ifdef TEST_LOG
5909 wxString s;
5910 for ( size_t n = 0; n < 8000; n++ )
5911 {
5912 s << (char)('A' + (n % 26));
5913 }
5914
5915 wxString msg;
5916 msg.Printf("A very very long message: '%s', the end!\n", s.c_str());
5917
5918 // this one shouldn't be truncated
5919 printf(msg);
5920
5921 // but this one will because log functions use fixed size buffer
5922 // (note that it doesn't need '\n' at the end neither - will be added
5923 // by wxLog anyhow)
5924 wxLogMessage("A very very long message 2: '%s', the end!", s.c_str());
5925 #endif // TEST_LOG
5926
5927 #ifdef TEST_FILE
5928 if ( TEST_ALL )
5929 {
5930 TestFileRead();
5931 TestTextFileRead();
5932 TestFileCopy();
5933 }
5934 #endif // TEST_FILE
5935
5936 #ifdef TEST_FILENAME
5937 if ( 0 )
5938 {
5939 wxFileName fn;
5940 fn.Assign("c:\\foo", "bar.baz");
5941 fn.Assign("/u/os9-port/Viewer/tvision/WEI2HZ-3B3-14_05-04-00MSC1.asc");
5942
5943 DumpFileName(fn);
5944 }
5945
5946 TestFileNameConstruction();
5947 if ( TEST_ALL )
5948 {
5949 TestFileNameConstruction();
5950 TestFileNameMakeRelative();
5951 TestFileNameSplit();
5952 TestFileNameTemp();
5953 TestFileNameCwd();
5954 TestFileNameComparison();
5955 TestFileNameOperations();
5956 }
5957 #endif // TEST_FILENAME
5958
5959 #ifdef TEST_FILETIME
5960 TestFileGetTimes();
5961 if ( 0 )
5962 TestFileSetTimes();
5963 #endif // TEST_FILETIME
5964
5965 #ifdef TEST_FTP
5966 wxLog::AddTraceMask(FTP_TRACE_MASK);
5967 if ( TestFtpConnect() )
5968 {
5969 if ( TEST_ALL )
5970 {
5971 TestFtpList();
5972 TestFtpDownload();
5973 TestFtpMisc();
5974 TestFtpFileSize();
5975 TestFtpUpload();
5976 }
5977
5978 if ( TEST_INTERACTIVE )
5979 TestFtpInteractive();
5980 }
5981 //else: connecting to the FTP server failed
5982
5983 if ( 0 )
5984 TestFtpWuFtpd();
5985 #endif // TEST_FTP
5986
5987 #ifdef TEST_LONGLONG
5988 // seed pseudo random generator
5989 srand((unsigned)time(NULL));
5990
5991 if ( 0 )
5992 {
5993 TestSpeed();
5994 }
5995
5996 if ( TEST_ALL )
5997 {
5998 TestMultiplication();
5999 TestDivision();
6000 TestAddition();
6001 TestLongLongConversion();
6002 TestBitOperations();
6003 TestLongLongComparison();
6004 TestLongLongPrint();
6005 }
6006 #endif // TEST_LONGLONG
6007
6008 #ifdef TEST_HASH
6009 TestHash();
6010 #endif // TEST_HASH
6011
6012 #ifdef TEST_HASHMAP
6013 TestHashMap();
6014 #endif // TEST_HASHMAP
6015
6016 #ifdef TEST_MIME
6017 wxLog::AddTraceMask(_T("mime"));
6018 if ( TEST_ALL )
6019 {
6020 TestMimeEnum();
6021 TestMimeOverride();
6022 TestMimeAssociate();
6023 }
6024 TestMimeFilename();
6025 #endif // TEST_MIME
6026
6027 #ifdef TEST_INFO_FUNCTIONS
6028 if ( TEST_ALL )
6029 {
6030 TestOsInfo();
6031 TestUserInfo();
6032
6033 if ( TEST_INTERACTIVE )
6034 TestDiskInfo();
6035 }
6036 #endif // TEST_INFO_FUNCTIONS
6037
6038 #ifdef TEST_PATHLIST
6039 TestPathList();
6040 #endif // TEST_PATHLIST
6041
6042 #ifdef TEST_ODBC
6043 TestDbOpen();
6044 #endif // TEST_ODBC
6045
6046 #ifdef TEST_REGCONF
6047 TestRegConfWrite();
6048 #endif // TEST_REGCONF
6049
6050 #ifdef TEST_REGEX
6051 // TODO: write a real test using src/regex/tests file
6052 if ( TEST_ALL )
6053 {
6054 TestRegExCompile();
6055 TestRegExMatch();
6056 TestRegExSubmatch();
6057 TestRegExReplacement();
6058
6059 if ( TEST_INTERACTIVE )
6060 TestRegExInteractive();
6061 }
6062 #endif // TEST_REGEX
6063
6064 #ifdef TEST_REGISTRY
6065 TestRegistryRead();
6066 TestRegistryAssociation();
6067 #endif // TEST_REGISTRY
6068
6069 #ifdef TEST_SOCKETS
6070 TestSocketServer();
6071 TestSocketClient();
6072 #endif // TEST_SOCKETS
6073
6074 #ifdef TEST_STREAMS
6075 if ( TEST_ALL )
6076 {
6077 TestFileStream();
6078 }
6079 TestMemoryStream();
6080 #endif // TEST_STREAMS
6081
6082 #ifdef TEST_THREADS
6083 int nCPUs = wxThread::GetCPUCount();
6084 printf("This system has %d CPUs\n", nCPUs);
6085 if ( nCPUs != -1 )
6086 wxThread::SetConcurrency(nCPUs);
6087
6088 if ( TEST_ALL )
6089 {
6090 TestDetachedThreads();
6091 TestJoinableThreads();
6092 TestThreadSuspend();
6093 TestThreadDelete();
6094 TestThreadConditions();
6095 TestThreadExec();
6096 }
6097
6098 TestSemaphore();
6099 #endif // TEST_THREADS
6100
6101 #ifdef TEST_TIMER
6102 TestStopWatch();
6103 #endif // TEST_TIMER
6104
6105 #ifdef TEST_DATETIME
6106 if ( TEST_ALL )
6107 {
6108 TestTimeSet();
6109 TestTimeStatic();
6110 TestTimeRange();
6111 TestTimeZones();
6112 TestTimeTicks();
6113 TestTimeJDN();
6114 TestTimeDST();
6115 TestTimeWDays();
6116 TestTimeWNumber();
6117 TestTimeParse();
6118 TestTimeArithmetics();
6119 TestTimeHolidays();
6120 TestTimeFormat();
6121 TestTimeSpanFormat();
6122 TestTimeMS();
6123
6124 TestTimeZoneBug();
6125 }
6126
6127 if ( TEST_INTERACTIVE )
6128 TestDateTimeInteractive();
6129 #endif // TEST_DATETIME
6130
6131 #ifdef TEST_USLEEP
6132 puts("Sleeping for 3 seconds... z-z-z-z-z...");
6133 wxUsleep(3000);
6134 #endif // TEST_USLEEP
6135
6136 #ifdef TEST_VCARD
6137 TestVCardRead();
6138 TestVCardWrite();
6139 #endif // TEST_VCARD
6140
6141 #ifdef TEST_VOLUME
6142 TestFSVolume();
6143 #endif // TEST_VOLUME
6144
6145 #ifdef TEST_UNICODE
6146 TestUnicodeToFromAscii();
6147 #endif // TEST_UNICODE
6148
6149 #ifdef TEST_WCHAR
6150 TestUtf8();
6151 TestEncodingConverter();
6152 #endif // TEST_WCHAR
6153
6154 #ifdef TEST_ZIP
6155 TestZipStreamRead();
6156 TestZipFileSystem();
6157 #endif // TEST_ZIP
6158
6159 #ifdef TEST_ZLIB
6160 TestZlibStreamWrite();
6161 TestZlibStreamRead();
6162 #endif // TEST_ZLIB
6163
6164 return 0;
6165 }
6166
wxWidgets (Impactor)