]> git.saurik.com Git - wxWidgets.git/blob - samples/console/console.cpp
projects / wxWidgets.git / blob
? search:


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