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