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