]> git.saurik.com Git - wxWidgets.git/blob - samples/console/console.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
made wxNativePixelFormat usable under Mac
[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_FILECONF
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 // sockets
2990 // ----------------------------------------------------------------------------
2991
2992 #ifdef TEST_SOCKETS
2993
2994 #include "wx/socket.h"
2995 #include "wx/protocol/protocol.h"
2996 #include "wx/protocol/http.h"
2997
2998 static void TestSocketServer()
2999 {
3000 wxPuts(_T("*** Testing wxSocketServer ***\n"));
3001
3002 static const int PORT = 3000;
3003
3004 wxIPV4address addr;
3005 addr.Service(PORT);
3006
3007 wxSocketServer *server = new wxSocketServer(addr);
3008 if ( !server->Ok() )
3009 {
3010 wxPuts(_T("ERROR: failed to bind"));
3011
3012 return;
3013 }
3014
3015 bool quit = false;
3016 while ( !quit )
3017 {
3018 wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
3019
3020 wxSocketBase *socket = server->Accept();
3021 if ( !socket )
3022 {
3023 wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
3024 break;
3025 }
3026
3027 wxPuts(_T("Server: got a client."));
3028
3029 server->SetTimeout(60); // 1 min
3030
3031 bool close = false;
3032 while ( !close && socket->IsConnected() )
3033 {
3034 wxString s;
3035 wxChar ch = _T('\0');
3036 for ( ;; )
3037 {
3038 if ( socket->Read(&ch, sizeof(ch)).Error() )
3039 {
3040 // don't log error if the client just close the connection
3041 if ( socket->IsConnected() )
3042 {
3043 wxPuts(_T("ERROR: in wxSocket::Read."));
3044 }
3045
3046 break;
3047 }
3048
3049 if ( ch == '\r' )
3050 continue;
3051
3052 if ( ch == '\n' )
3053 break;
3054
3055 s += ch;
3056 }
3057
3058 if ( ch != '\n' )
3059 {
3060 break;
3061 }
3062
3063 wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
3064 if ( s == _T("close") )
3065 {
3066 wxPuts(_T("Closing connection"));
3067
3068 close = true;
3069 }
3070 else if ( s == _T("quit") )
3071 {
3072 close =
3073 quit = true;
3074
3075 wxPuts(_T("Shutting down the server"));
3076 }
3077 else // not a special command
3078 {
3079 socket->Write(s.MakeUpper().c_str(), s.length());
3080 socket->Write("\r\n", 2);
3081 wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
3082 }
3083 }
3084
3085 if ( !close )
3086 {
3087 wxPuts(_T("Server: lost a client unexpectedly."));
3088 }
3089
3090 socket->Destroy();
3091 }
3092
3093 // same as "delete server" but is consistent with GUI programs
3094 server->Destroy();
3095 }
3096
3097 static void TestSocketClient()
3098 {
3099 wxPuts(_T("*** Testing wxSocketClient ***\n"));
3100
3101 static const wxChar *hostname = _T("www.wxwindows.org");
3102
3103 wxIPV4address addr;
3104 addr.Hostname(hostname);
3105 addr.Service(80);
3106
3107 wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
3108
3109 wxSocketClient client;
3110 if ( !client.Connect(addr) )
3111 {
3112 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
3113 }
3114 else
3115 {
3116 wxPrintf(_T("--- Connected to %s:%u...\n"),
3117 addr.Hostname().c_str(), addr.Service());
3118
3119 wxChar buf[8192];
3120
3121 // could use simply "GET" here I suppose
3122 wxString cmdGet =
3123 wxString::Format(_T("GET http://%s/\r\n"), hostname);
3124 client.Write(cmdGet, cmdGet.length());
3125 wxPrintf(_T("--- Sent command '%s' to the server\n"),
3126 MakePrintable(cmdGet).c_str());
3127 client.Read(buf, WXSIZEOF(buf));
3128 wxPrintf(_T("--- Server replied:\n%s"), buf);
3129 }
3130 }
3131
3132 #endif // TEST_SOCKETS
3133
3134 // ----------------------------------------------------------------------------
3135 // FTP
3136 // ----------------------------------------------------------------------------
3137
3138 #ifdef TEST_FTP
3139
3140 #include "wx/protocol/ftp.h"
3141
3142 static wxFTP ftp;
3143
3144 #define FTP_ANONYMOUS
3145
3146 #ifdef FTP_ANONYMOUS
3147 static const wxChar *directory = _T("/pub");
3148 static const wxChar *filename = _T("welcome.msg");
3149 #else
3150 static const wxChar *directory = _T("/etc");
3151 static const wxChar *filename = _T("issue");
3152 #endif
3153
3154 static bool TestFtpConnect()
3155 {
3156 wxPuts(_T("*** Testing FTP connect ***"));
3157
3158 #ifdef FTP_ANONYMOUS
3159 static const wxChar *hostname = _T("ftp.wxwindows.org");
3160
3161 wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
3162 #else // !FTP_ANONYMOUS
3163 static const wxChar *hostname = "localhost";
3164
3165 wxChar user[256];
3166 wxFgets(user, WXSIZEOF(user), stdin);
3167 user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
3168 ftp.SetUser(user);
3169
3170 wxChar password[256];
3171 wxPrintf(_T("Password for %s: "), password);
3172 wxFgets(password, WXSIZEOF(password), stdin);
3173 password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
3174 ftp.SetPassword(password);
3175
3176 wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
3177 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
3178
3179 if ( !ftp.Connect(hostname) )
3180 {
3181 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
3182
3183 return false;
3184 }
3185 else
3186 {
3187 wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
3188 hostname, ftp.Pwd().c_str());
3189 }
3190
3191 return true;
3192 }
3193
3194 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
3195 static void TestFtpWuFtpd()
3196 {
3197 wxFTP ftp;
3198 static const wxChar *hostname = _T("ftp.eudora.com");
3199 if ( !ftp.Connect(hostname) )
3200 {
3201 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
3202 }
3203 else
3204 {
3205 static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
3206 wxInputStream *in = ftp.GetInputStream(filename);
3207 if ( !in )
3208 {
3209 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
3210 }
3211 else
3212 {
3213 size_t size = in->GetSize();
3214 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
3215
3216 wxChar *data = new wxChar[size];
3217 if ( !in->Read(data, size) )
3218 {
3219 wxPuts(_T("ERROR: read error"));
3220 }
3221 else
3222 {
3223 wxPrintf(_T("Successfully retrieved the file.\n"));
3224 }
3225
3226 delete [] data;
3227 delete in;
3228 }
3229 }
3230 }
3231
3232 static void TestFtpList()
3233 {
3234 wxPuts(_T("*** Testing wxFTP file listing ***\n"));
3235
3236 // test CWD
3237 if ( !ftp.ChDir(directory) )
3238 {
3239 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
3240 }
3241
3242 wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
3243
3244 // test NLIST and LIST
3245 wxArrayString files;
3246 if ( !ftp.GetFilesList(files) )
3247 {
3248 wxPuts(_T("ERROR: failed to get NLIST of files"));
3249 }
3250 else
3251 {
3252 wxPrintf(_T("Brief list of files under '%s':\n"), ftp.Pwd().c_str());
3253 size_t count = files.GetCount();
3254 for ( size_t n = 0; n < count; n++ )
3255 {
3256 wxPrintf(_T("\t%s\n"), files[n].c_str());
3257 }
3258 wxPuts(_T("End of the file list"));
3259 }
3260
3261 if ( !ftp.GetDirList(files) )
3262 {
3263 wxPuts(_T("ERROR: failed to get LIST of files"));
3264 }
3265 else
3266 {
3267 wxPrintf(_T("Detailed list of files under '%s':\n"), ftp.Pwd().c_str());
3268 size_t count = files.GetCount();
3269 for ( size_t n = 0; n < count; n++ )
3270 {
3271 wxPrintf(_T("\t%s\n"), files[n].c_str());
3272 }
3273 wxPuts(_T("End of the file list"));
3274 }
3275
3276 if ( !ftp.ChDir(_T("..")) )
3277 {
3278 wxPuts(_T("ERROR: failed to cd to .."));
3279 }
3280
3281 wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
3282 }
3283
3284 static void TestFtpDownload()
3285 {
3286 wxPuts(_T("*** Testing wxFTP download ***\n"));
3287
3288 // test RETR
3289 wxInputStream *in = ftp.GetInputStream(filename);
3290 if ( !in )
3291 {
3292 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
3293 }
3294 else
3295 {
3296 size_t size = in->GetSize();
3297 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
3298 fflush(stdout);
3299
3300 wxChar *data = new wxChar[size];
3301 if ( !in->Read(data, size) )
3302 {
3303 wxPuts(_T("ERROR: read error"));
3304 }
3305 else
3306 {
3307 wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
3308 }
3309
3310 delete [] data;
3311 delete in;
3312 }
3313 }
3314
3315 static void TestFtpFileSize()
3316 {
3317 wxPuts(_T("*** Testing FTP SIZE command ***"));
3318
3319 if ( !ftp.ChDir(directory) )
3320 {
3321 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
3322 }
3323
3324 wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
3325
3326 if ( ftp.FileExists(filename) )
3327 {
3328 int size = ftp.GetFileSize(filename);
3329 if ( size == -1 )
3330 wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
3331 else
3332 wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
3333 }
3334 else
3335 {
3336 wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
3337 }
3338 }
3339
3340 static void TestFtpMisc()
3341 {
3342 wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
3343
3344 if ( ftp.SendCommand("STAT") != '2' )
3345 {
3346 wxPuts(_T("ERROR: STAT failed"));
3347 }
3348 else
3349 {
3350 wxPrintf(_T("STAT returned:\n\n%s\n"), ftp.GetLastResult().c_str());
3351 }
3352
3353 if ( ftp.SendCommand("HELP SITE") != '2' )
3354 {
3355 wxPuts(_T("ERROR: HELP SITE failed"));
3356 }
3357 else
3358 {
3359 wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
3360 ftp.GetLastResult().c_str());
3361 }
3362 }
3363
3364 static void TestFtpInteractive()
3365 {
3366 wxPuts(_T("\n*** Interactive wxFTP test ***"));
3367
3368 wxChar buf[128];
3369
3370 for ( ;; )
3371 {
3372 wxPrintf(_T("Enter FTP command: "));
3373 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
3374 break;
3375
3376 // kill the last '\n'
3377 buf[wxStrlen(buf) - 1] = 0;
3378
3379 // special handling of LIST and NLST as they require data connection
3380 wxString start(buf, 4);
3381 start.MakeUpper();
3382 if ( start == "LIST" || start == "NLST" )
3383 {
3384 wxString wildcard;
3385 if ( wxStrlen(buf) > 4 )
3386 wildcard = buf + 5;
3387
3388 wxArrayString files;
3389 if ( !ftp.GetList(files, wildcard, start == "LIST") )
3390 {
3391 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
3392 }
3393 else
3394 {
3395 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
3396 start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
3397 size_t count = files.GetCount();
3398 for ( size_t n = 0; n < count; n++ )
3399 {
3400 wxPrintf(_T("\t%s\n"), files[n].c_str());
3401 }
3402 wxPuts(_T("--- End of the file list"));
3403 }
3404 }
3405 else // !list
3406 {
3407 wxChar ch = ftp.SendCommand(buf);
3408 wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
3409 if ( ch )
3410 {
3411 wxPrintf(_T(" (return code %c)"), ch);
3412 }
3413
3414 wxPrintf(_T(", server reply:\n%s\n\n"), ftp.GetLastResult().c_str());
3415 }
3416 }
3417
3418 wxPuts(_T("\n*** done ***"));
3419 }
3420
3421 static void TestFtpUpload()
3422 {
3423 wxPuts(_T("*** Testing wxFTP uploading ***\n"));
3424
3425 // upload a file
3426 static const wxChar *file1 = _T("test1");
3427 static const wxChar *file2 = _T("test2");
3428 wxOutputStream *out = ftp.GetOutputStream(file1);
3429 if ( out )
3430 {
3431 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
3432 out->Write("First hello", 11);
3433 delete out;
3434 }
3435
3436 // send a command to check the remote file
3437 if ( ftp.SendCommand(wxString("STAT ") + file1) != '2' )
3438 {
3439 wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
3440 }
3441 else
3442 {
3443 wxPrintf(_T("STAT %s returned:\n\n%s\n"),
3444 file1, ftp.GetLastResult().c_str());
3445 }
3446
3447 out = ftp.GetOutputStream(file2);
3448 if ( out )
3449 {
3450 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
3451 out->Write("Second hello", 12);
3452 delete out;
3453 }
3454 }
3455
3456 #endif // TEST_FTP
3457
3458 // ----------------------------------------------------------------------------
3459 // streams
3460 // ----------------------------------------------------------------------------
3461
3462 #ifdef TEST_STREAMS
3463
3464 #include "wx/wfstream.h"
3465 #include "wx/mstream.h"
3466
3467 static void TestFileStream()
3468 {
3469 wxPuts(_T("*** Testing wxFileInputStream ***"));
3470
3471 static const wxChar *filename = _T("testdata.fs");
3472 {
3473 wxFileOutputStream fsOut(filename);
3474 fsOut.Write("foo", 3);
3475 }
3476
3477 wxFileInputStream fsIn(filename);
3478 wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
3479 while ( !fsIn.Eof() )
3480 {
3481 putchar(fsIn.GetC());
3482 }
3483
3484 if ( !wxRemoveFile(filename) )
3485 {
3486 wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename);
3487 }
3488
3489 wxPuts(_T("\n*** wxFileInputStream test done ***"));
3490 }
3491
3492 static void TestMemoryStream()
3493 {
3494 wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
3495
3496 wxMemoryOutputStream memOutStream;
3497 wxPrintf(_T("Initially out stream offset: %lu\n"),
3498 (unsigned long)memOutStream.TellO());
3499
3500 for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
3501 {
3502 memOutStream.PutC(*p);
3503 }
3504
3505 wxPrintf(_T("Final out stream offset: %lu\n"),
3506 (unsigned long)memOutStream.TellO());
3507
3508 wxPuts(_T("*** Testing wxMemoryInputStream ***"));
3509
3510 wxChar buf[1024];
3511 size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
3512
3513 wxMemoryInputStream memInpStream(buf, len);
3514 wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
3515 while ( !memInpStream.Eof() )
3516 {
3517 putchar(memInpStream.GetC());
3518 }
3519
3520 wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
3521 }
3522
3523 #endif // TEST_STREAMS
3524
3525 // ----------------------------------------------------------------------------
3526 // timers
3527 // ----------------------------------------------------------------------------
3528
3529 #ifdef TEST_TIMER
3530
3531 #include "wx/timer.h"
3532 #include "wx/utils.h"
3533
3534 static void TestStopWatch()
3535 {
3536 wxPuts(_T("*** Testing wxStopWatch ***\n"));
3537
3538 wxStopWatch sw;
3539 sw.Pause();
3540 wxPrintf(_T("Initially paused, after 2 seconds time is..."));
3541 fflush(stdout);
3542 wxSleep(2);
3543 wxPrintf(_T("\t%ldms\n"), sw.Time());
3544
3545 wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
3546 fflush(stdout);
3547 sw.Resume();
3548 wxSleep(3);
3549 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3550
3551 sw.Pause();
3552 wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
3553 fflush(stdout);
3554 wxSleep(2);
3555 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3556
3557 sw.Resume();
3558 wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
3559 fflush(stdout);
3560 wxSleep(2);
3561 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3562
3563 wxStopWatch sw2;
3564 wxPuts(_T("\nChecking for 'backwards clock' bug..."));
3565 for ( size_t n = 0; n < 70; n++ )
3566 {
3567 sw2.Start();
3568
3569 for ( size_t m = 0; m < 100000; m++ )
3570 {
3571 if ( sw.Time() < 0 || sw2.Time() < 0 )
3572 {
3573 wxPuts(_T("\ntime is negative - ERROR!"));
3574 }
3575 }
3576
3577 putchar('.');
3578 fflush(stdout);
3579 }
3580
3581 wxPuts(_T(", ok."));
3582 }
3583
3584 #endif // TEST_TIMER
3585
3586 // ----------------------------------------------------------------------------
3587 // vCard support
3588 // ----------------------------------------------------------------------------
3589
3590 #ifdef TEST_VCARD
3591
3592 #include "wx/vcard.h"
3593
3594 static void DumpVObject(size_t level, const wxVCardObject& vcard)
3595 {
3596 void *cookie;
3597 wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3598 while ( vcObj )
3599 {
3600 wxPrintf(_T("%s%s"),
3601 wxString(_T('\t'), level).c_str(),
3602 vcObj->GetName().c_str());
3603
3604 wxString value;
3605 switch ( vcObj->GetType() )
3606 {
3607 case wxVCardObject::String:
3608 case wxVCardObject::UString:
3609 {
3610 wxString val;
3611 vcObj->GetValue(&val);
3612 value << _T('"') << val << _T('"');
3613 }
3614 break;
3615
3616 case wxVCardObject::Int:
3617 {
3618 unsigned int i;
3619 vcObj->GetValue(&i);
3620 value.Printf(_T("%u"), i);
3621 }
3622 break;
3623
3624 case wxVCardObject::Long:
3625 {
3626 unsigned long l;
3627 vcObj->GetValue(&l);
3628 value.Printf(_T("%lu"), l);
3629 }
3630 break;
3631
3632 case wxVCardObject::None:
3633 break;
3634
3635 case wxVCardObject::Object:
3636 value = _T("<node>");
3637 break;
3638
3639 default:
3640 value = _T("<unknown value type>");
3641 }
3642
3643 if ( !!value )
3644 wxPrintf(_T(" = %s"), value.c_str());
3645 putchar('\n');
3646
3647 DumpVObject(level + 1, *vcObj);
3648
3649 delete vcObj;
3650 vcObj = vcard.GetNextProp(&cookie);
3651 }
3652 }
3653
3654 static void DumpVCardAddresses(const wxVCard& vcard)
3655 {
3656 wxPuts(_T("\nShowing all addresses from vCard:\n"));
3657
3658 size_t nAdr = 0;
3659 void *cookie;
3660 wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3661 while ( addr )
3662 {
3663 wxString flagsStr;
3664 int flags = addr->GetFlags();
3665 if ( flags & wxVCardAddress::Domestic )
3666 {
3667 flagsStr << _T("domestic ");
3668 }
3669 if ( flags & wxVCardAddress::Intl )
3670 {
3671 flagsStr << _T("international ");
3672 }
3673 if ( flags & wxVCardAddress::Postal )
3674 {
3675 flagsStr << _T("postal ");
3676 }
3677 if ( flags & wxVCardAddress::Parcel )
3678 {
3679 flagsStr << _T("parcel ");
3680 }
3681 if ( flags & wxVCardAddress::Home )
3682 {
3683 flagsStr << _T("home ");
3684 }
3685 if ( flags & wxVCardAddress::Work )
3686 {
3687 flagsStr << _T("work ");
3688 }
3689
3690 wxPrintf(_T("Address %u:\n")
3691 "\tflags = %s\n"
3692 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3693 ++nAdr,
3694 flagsStr.c_str(),
3695 addr->GetPostOffice().c_str(),
3696 addr->GetExtAddress().c_str(),
3697 addr->GetStreet().c_str(),
3698 addr->GetLocality().c_str(),
3699 addr->GetRegion().c_str(),
3700 addr->GetPostalCode().c_str(),
3701 addr->GetCountry().c_str()
3702 );
3703
3704 delete addr;
3705 addr = vcard.GetNextAddress(&cookie);
3706 }
3707 }
3708
3709 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
3710 {
3711 wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
3712
3713 size_t nPhone = 0;
3714 void *cookie;
3715 wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
3716 while ( phone )
3717 {
3718 wxString flagsStr;
3719 int flags = phone->GetFlags();
3720 if ( flags & wxVCardPhoneNumber::Voice )
3721 {
3722 flagsStr << _T("voice ");
3723 }
3724 if ( flags & wxVCardPhoneNumber::Fax )
3725 {
3726 flagsStr << _T("fax ");
3727 }
3728 if ( flags & wxVCardPhoneNumber::Cellular )
3729 {
3730 flagsStr << _T("cellular ");
3731 }
3732 if ( flags & wxVCardPhoneNumber::Modem )
3733 {
3734 flagsStr << _T("modem ");
3735 }
3736 if ( flags & wxVCardPhoneNumber::Home )
3737 {
3738 flagsStr << _T("home ");
3739 }
3740 if ( flags & wxVCardPhoneNumber::Work )
3741 {
3742 flagsStr << _T("work ");
3743 }
3744
3745 wxPrintf(_T("Phone number %u:\n")
3746 "\tflags = %s\n"
3747 "\tvalue = %s\n",
3748 ++nPhone,
3749 flagsStr.c_str(),
3750 phone->GetNumber().c_str()
3751 );
3752
3753 delete phone;
3754 phone = vcard.GetNextPhoneNumber(&cookie);
3755 }
3756 }
3757
3758 static void TestVCardRead()
3759 {
3760 wxPuts(_T("*** Testing wxVCard reading ***\n"));
3761
3762 wxVCard vcard(_T("vcard.vcf"));
3763 if ( !vcard.IsOk() )
3764 {
3765 wxPuts(_T("ERROR: couldn't load vCard."));
3766 }
3767 else
3768 {
3769 // read individual vCard properties
3770 wxVCardObject *vcObj = vcard.GetProperty("FN");
3771 wxString value;
3772 if ( vcObj )
3773 {
3774 vcObj->GetValue(&value);
3775 delete vcObj;
3776 }
3777 else
3778 {
3779 value = _T("<none>");
3780 }
3781
3782 wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
3783
3784
3785 if ( !vcard.GetFullName(&value) )
3786 {
3787 value = _T("<none>");
3788 }
3789
3790 wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
3791
3792 // now show how to deal with multiply occuring properties
3793 DumpVCardAddresses(vcard);
3794 DumpVCardPhoneNumbers(vcard);
3795
3796 // and finally show all
3797 wxPuts(_T("\nNow dumping the entire vCard:\n")
3798 "-----------------------------\n");
3799
3800 DumpVObject(0, vcard);
3801 }
3802 }
3803
3804 static void TestVCardWrite()
3805 {
3806 wxPuts(_T("*** Testing wxVCard writing ***\n"));
3807
3808 wxVCard vcard;
3809 if ( !vcard.IsOk() )
3810 {
3811 wxPuts(_T("ERROR: couldn't create vCard."));
3812 }
3813 else
3814 {
3815 // set some fields
3816 vcard.SetName("Zeitlin", "Vadim");
3817 vcard.SetFullName("Vadim Zeitlin");
3818 vcard.SetOrganization("wxWindows", "R&D");
3819
3820 // just dump the vCard back
3821 wxPuts(_T("Entire vCard follows:\n"));
3822 wxPuts(vcard.Write());
3823 }
3824 }
3825
3826 #endif // TEST_VCARD
3827
3828 // ----------------------------------------------------------------------------
3829 // wxVolume tests
3830 // ----------------------------------------------------------------------------
3831
3832 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
3833 #undef TEST_VOLUME
3834 #endif
3835
3836 #ifdef TEST_VOLUME
3837
3838 #include "wx/volume.h"
3839
3840 static const wxChar *volumeKinds[] =
3841 {
3842 _T("floppy"),
3843 _T("hard disk"),
3844 _T("CD-ROM"),
3845 _T("DVD-ROM"),
3846 _T("network volume"),
3847 _T("other volume"),
3848 };
3849
3850 static void TestFSVolume()
3851 {
3852 wxPuts(_T("*** Testing wxFSVolume class ***"));
3853
3854 wxArrayString volumes = wxFSVolume::GetVolumes();
3855 size_t count = volumes.GetCount();
3856
3857 if ( !count )
3858 {
3859 wxPuts(_T("ERROR: no mounted volumes?"));
3860 return;
3861 }
3862
3863 wxPrintf(_T("%u mounted volumes found:\n"), count);
3864
3865 for ( size_t n = 0; n < count; n++ )
3866 {
3867 wxFSVolume vol(volumes[n]);
3868 if ( !vol.IsOk() )
3869 {
3870 wxPuts(_T("ERROR: couldn't create volume"));
3871 continue;
3872 }
3873
3874 wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3875 n + 1,
3876 vol.GetDisplayName().c_str(),
3877 vol.GetName().c_str(),
3878 volumeKinds[vol.GetKind()],
3879 vol.IsWritable() ? _T("rw") : _T("ro"),
3880 vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3881 : _T("fixed"));
3882 }
3883 }
3884
3885 #endif // TEST_VOLUME
3886
3887 // ----------------------------------------------------------------------------
3888 // wide char and Unicode support
3889 // ----------------------------------------------------------------------------
3890
3891 #ifdef TEST_UNICODE
3892
3893 static void TestUnicodeToFromAscii()
3894 {
3895 wxPuts(_T("Testing wxString::To/FromAscii()\n"));
3896
3897 static const char *msg = "Hello, world!";
3898 wxString s = wxString::FromAscii(msg);
3899
3900 wxPrintf(_T("Message in Unicode: %s\n"), s.c_str());
3901 printf("Message in ASCII: %s\n", (const char *)s.ToAscii());
3902
3903 wxPutchar(_T('\n'));
3904 }
3905
3906 #endif // TEST_UNICODE
3907
3908 #ifdef TEST_WCHAR
3909
3910 #include "wx/strconv.h"
3911 #include "wx/fontenc.h"
3912 #include "wx/encconv.h"
3913 #include "wx/buffer.h"
3914
3915 static const unsigned char utf8koi8r[] =
3916 {
3917 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3918 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3919 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3920 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3921 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3922 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3923 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3924 };
3925
3926 static const unsigned char utf8iso8859_1[] =
3927 {
3928 0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3929 0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3930 0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3931 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3932 0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3933 };
3934
3935 static const unsigned char utf8Invalid[] =
3936 {
3937 0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3938 0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3939 0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3940 0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3941 0x6c, 0x61, 0x79, 0
3942 };
3943
3944 static const struct Utf8Data
3945 {
3946 const unsigned char *text;
3947 size_t len;
3948 const wxChar *charset;
3949 wxFontEncoding encoding;
3950 } utf8data[] =
3951 {
3952 { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3953 { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3954 { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3955 };
3956
3957 static void TestUtf8()
3958 {
3959 wxPuts(_T("*** Testing UTF8 support ***\n"));
3960
3961 char buf[1024];
3962 wchar_t wbuf[1024];
3963
3964 for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
3965 {
3966 const Utf8Data& u8d = utf8data[n];
3967 if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3968 WXSIZEOF(wbuf)) == (size_t)-1 )
3969 {
3970 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3971 }
3972 else
3973 {
3974 wxCSConv conv(u8d.charset);
3975 if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3976 {
3977 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3978 }
3979 else
3980 {
3981 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3982 }
3983 }
3984
3985 wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text), *wxConvCurrent);
3986 if ( s.empty() )
3987 s = _T("<< conversion failed >>");
3988 wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3989
3990 }
3991
3992 wxPuts(_T(""));
3993 }
3994
3995 static void TestEncodingConverter()
3996 {
3997 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3998
3999 // using wxEncodingConverter should give the same result as above
4000 char buf[1024];
4001 wchar_t wbuf[1024];
4002 if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
4003 WXSIZEOF(utf8koi8r)) == (size_t)-1 )
4004 {
4005 wxPuts(_T("ERROR: UTF-8 decoding failed."));
4006 }
4007 else
4008 {
4009 wxEncodingConverter ec;
4010 ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
4011 ec.Convert(wbuf, buf);
4012 wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
4013 }
4014
4015 wxPuts(_T(""));
4016 }
4017
4018 #endif // TEST_WCHAR
4019
4020 // ----------------------------------------------------------------------------
4021 // ZIP stream
4022 // ----------------------------------------------------------------------------
4023
4024 #ifdef TEST_ZIP
4025
4026 #include "wx/filesys.h"
4027 #include "wx/fs_zip.h"
4028 #include "wx/zipstrm.h"
4029
4030 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
4031
4032 static void TestZipStreamRead()
4033 {
4034 wxPuts(_T("*** Testing ZIP reading ***\n"));
4035
4036 static const wxChar *filename = _T("foo");
4037 wxZipInputStream istr(TESTFILE_ZIP, filename);
4038 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
4039
4040 wxPrintf(_T("Dumping the file '%s':\n"), filename);
4041 while ( !istr.Eof() )
4042 {
4043 putchar(istr.GetC());
4044 fflush(stdout);
4045 }
4046
4047 wxPuts(_T("\n----- done ------"));
4048 }
4049
4050 static void DumpZipDirectory(wxFileSystem& fs,
4051 const wxString& dir,
4052 const wxString& indent)
4053 {
4054 wxString prefix = wxString::Format(_T("%s#zip:%s"),
4055 TESTFILE_ZIP, dir.c_str());
4056 wxString wildcard = prefix + _T("/*");
4057
4058 wxString dirname = fs.FindFirst(wildcard, wxDIR);
4059 while ( !dirname.empty() )
4060 {
4061 if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
4062 {
4063 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
4064
4065 break;
4066 }
4067
4068 wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
4069
4070 DumpZipDirectory(fs, dirname,
4071 indent + wxString(_T(' '), 4));
4072
4073 dirname = fs.FindNext();
4074 }
4075
4076 wxString filename = fs.FindFirst(wildcard, wxFILE);
4077 while ( !filename.empty() )
4078 {
4079 if ( !filename.StartsWith(prefix, &filename) )
4080 {
4081 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
4082
4083 break;
4084 }
4085
4086 wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
4087
4088 filename = fs.FindNext();
4089 }
4090 }
4091
4092 static void TestZipFileSystem()
4093 {
4094 wxPuts(_T("*** Testing ZIP file system ***\n"));
4095
4096 wxFileSystem::AddHandler(new wxZipFSHandler);
4097 wxFileSystem fs;
4098 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
4099
4100 DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
4101 }
4102
4103 #endif // TEST_ZIP
4104
4105 // ----------------------------------------------------------------------------
4106 // ZLIB stream
4107 // ----------------------------------------------------------------------------
4108
4109 #ifdef TEST_ZLIB
4110
4111 #include "wx/zstream.h"
4112 #include "wx/wfstream.h"
4113
4114 static const wxChar *FILENAME_GZ = _T("test.gz");
4115 static const wxChar *TEST_DATA = _T("hello and hello and hello and hello and hello");
4116
4117 static void TestZlibStreamWrite()
4118 {
4119 wxPuts(_T("*** Testing Zlib stream reading ***\n"));
4120
4121 wxFileOutputStream fileOutStream(FILENAME_GZ);
4122 wxZlibOutputStream ostr(fileOutStream);
4123 wxPrintf(_T("Compressing the test string... "));
4124 ostr.Write(TEST_DATA, wxStrlen(TEST_DATA) + 1);
4125 if ( !ostr )
4126 {
4127 wxPuts(_T("(ERROR: failed)"));
4128 }
4129 else
4130 {
4131 wxPuts(_T("(ok)"));
4132 }
4133
4134 wxPuts(_T("\n----- done ------"));
4135 }
4136
4137 static void TestZlibStreamRead()
4138 {
4139 wxPuts(_T("*** Testing Zlib stream reading ***\n"));
4140
4141 wxFileInputStream fileInStream(FILENAME_GZ);
4142 wxZlibInputStream istr(fileInStream);
4143 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
4144
4145 wxPuts(_T("Dumping the file:"));
4146 while ( !istr.Eof() )
4147 {
4148 putchar(istr.GetC());
4149 fflush(stdout);
4150 }
4151
4152 wxPuts(_T("\n----- done ------"));
4153 }
4154
4155 #endif // TEST_ZLIB
4156
4157 // ----------------------------------------------------------------------------
4158 // date time
4159 // ----------------------------------------------------------------------------
4160
4161 #ifdef TEST_DATETIME
4162
4163 #include <math.h>
4164
4165 #include "wx/datetime.h"
4166
4167 // the test data
4168 struct Date
4169 {
4170 wxDateTime::wxDateTime_t day;
4171 wxDateTime::Month month;
4172 int year;
4173 wxDateTime::wxDateTime_t hour, min, sec;
4174 double jdn;
4175 wxDateTime::WeekDay wday;
4176 time_t gmticks, ticks;
4177
4178 void Init(const wxDateTime::Tm& tm)
4179 {
4180 day = tm.mday;
4181 month = tm.mon;
4182 year = tm.year;
4183 hour = tm.hour;
4184 min = tm.min;
4185 sec = tm.sec;
4186 jdn = 0.0;
4187 gmticks = ticks = -1;
4188 }
4189
4190 wxDateTime DT() const
4191 { return wxDateTime(day, month, year, hour, min, sec); }
4192
4193 bool SameDay(const wxDateTime::Tm& tm) const
4194 {
4195 return day == tm.mday && month == tm.mon && year == tm.year;
4196 }
4197
4198 wxString Format() const
4199 {
4200 wxString s;
4201 s.Printf(_T("%02d:%02d:%02d %10s %02d, %4d%s"),
4202 hour, min, sec,
4203 wxDateTime::GetMonthName(month).c_str(),
4204 day,
4205 abs(wxDateTime::ConvertYearToBC(year)),
4206 year > 0 ? _T("AD") : _T("BC"));
4207 return s;
4208 }
4209
4210 wxString FormatDate() const
4211 {
4212 wxString s;
4213 s.Printf(_T("%02d-%s-%4d%s"),
4214 day,
4215 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
4216 abs(wxDateTime::ConvertYearToBC(year)),
4217 year > 0 ? _T("AD") : _T("BC"));
4218 return s;
4219 }
4220 };
4221
4222 static const Date testDates[] =
4223 {
4224 { 1, wxDateTime::Jan, 1970, 00, 00, 00, 2440587.5, wxDateTime::Thu, 0, -3600 },
4225 { 7, wxDateTime::Feb, 2036, 00, 00, 00, 2464730.5, wxDateTime::Thu, -1, -1 },
4226 { 8, wxDateTime::Feb, 2036, 00, 00, 00, 2464731.5, wxDateTime::Fri, -1, -1 },
4227 { 1, wxDateTime::Jan, 2037, 00, 00, 00, 2465059.5, wxDateTime::Thu, -1, -1 },
4228 { 1, wxDateTime::Jan, 2038, 00, 00, 00, 2465424.5, wxDateTime::Fri, -1, -1 },
4229 { 21, wxDateTime::Jan, 2222, 00, 00, 00, 2532648.5, wxDateTime::Mon, -1, -1 },
4230 { 29, wxDateTime::May, 1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
4231 { 29, wxDateTime::Feb, 1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
4232 { 1, wxDateTime::Jan, 1900, 12, 00, 00, 2415021.0, wxDateTime::Mon, -1, -1 },
4233 { 1, wxDateTime::Jan, 1900, 00, 00, 00, 2415020.5, wxDateTime::Mon, -1, -1 },
4234 { 15, wxDateTime::Oct, 1582, 00, 00, 00, 2299160.5, wxDateTime::Fri, -1, -1 },
4235 { 4, wxDateTime::Oct, 1582, 00, 00, 00, 2299149.5, wxDateTime::Mon, -1, -1 },
4236 { 1, wxDateTime::Mar, 1, 00, 00, 00, 1721484.5, wxDateTime::Thu, -1, -1 },
4237 { 1, wxDateTime::Jan, 1, 00, 00, 00, 1721425.5, wxDateTime::Mon, -1, -1 },
4238 { 31, wxDateTime::Dec, 0, 00, 00, 00, 1721424.5, wxDateTime::Sun, -1, -1 },
4239 { 1, wxDateTime::Jan, 0, 00, 00, 00, 1721059.5, wxDateTime::Sat, -1, -1 },
4240 { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri, -1, -1 },
4241 { 12, wxDateTime::Aug, -4000, 00, 00, 00, 260313.5, wxDateTime::Sat, -1, -1 },
4242 { 24, wxDateTime::Nov, -4713, 00, 00, 00, -0.5, wxDateTime::Mon, -1, -1 },
4243 };
4244
4245 // this test miscellaneous static wxDateTime functions
4246 static void TestTimeStatic()
4247 {
4248 wxPuts(_T("\n*** wxDateTime static methods test ***"));
4249
4250 // some info about the current date
4251 int year = wxDateTime::GetCurrentYear();
4252 wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
4253 year,
4254 wxDateTime::IsLeapYear(year) ? "" : "not ",
4255 wxDateTime::GetNumberOfDays(year));
4256
4257 wxDateTime::Month month = wxDateTime::GetCurrentMonth();
4258 wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
4259 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
4260 wxDateTime::GetMonthName(month).c_str(),
4261 wxDateTime::GetNumberOfDays(month));
4262
4263 // leap year logic
4264 static const size_t nYears = 5;
4265 static const size_t years[2][nYears] =
4266 {
4267 // first line: the years to test
4268 { 1990, 1976, 2000, 2030, 1984, },
4269
4270 // second line: true if leap, false otherwise
4271 { false, true, true, false, true }
4272 };
4273
4274 for ( size_t n = 0; n < nYears; n++ )
4275 {
4276 int year = years[0][n];
4277 bool should = years[1][n] != 0,
4278 is = wxDateTime::IsLeapYear(year);
4279
4280 wxPrintf(_T("Year %d is %sa leap year (%s)\n"),
4281 year,
4282 is ? "" : "not ",
4283 should == is ? "ok" : "ERROR");
4284
4285 wxASSERT( should == wxDateTime::IsLeapYear(year) );
4286 }
4287 }
4288
4289 // test constructing wxDateTime objects
4290 static void TestTimeSet()
4291 {
4292 wxPuts(_T("\n*** wxDateTime construction test ***"));
4293
4294 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4295 {
4296 const Date& d1 = testDates[n];
4297 wxDateTime dt = d1.DT();
4298
4299 Date d2;
4300 d2.Init(dt.GetTm());
4301
4302 wxString s1 = d1.Format(),
4303 s2 = d2.Format();
4304
4305 wxPrintf(_T("Date: %s == %s (%s)\n"),
4306 s1.c_str(), s2.c_str(),
4307 s1 == s2 ? _T("ok") : _T("ERROR"));
4308 }
4309 }
4310
4311 // test time zones stuff
4312 static void TestTimeZones()
4313 {
4314 wxPuts(_T("\n*** wxDateTime timezone test ***"));
4315
4316 wxDateTime now = wxDateTime::Now();
4317
4318 wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
4319 wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
4320 wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
4321 wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
4322 wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
4323 wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
4324
4325 wxDateTime::Tm tm = now.GetTm();
4326 if ( wxDateTime(tm) != now )
4327 {
4328 wxPrintf(_T("ERROR: got %s instead of %s\n"),
4329 wxDateTime(tm).Format().c_str(), now.Format().c_str());
4330 }
4331 }
4332
4333 // test some minimal support for the dates outside the standard range
4334 static void TestTimeRange()
4335 {
4336 wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
4337
4338 static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
4339
4340 wxPrintf(_T("Unix epoch:\t%s\n"),
4341 wxDateTime(2440587.5).Format(fmt).c_str());
4342 wxPrintf(_T("Feb 29, 0: \t%s\n"),
4343 wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
4344 wxPrintf(_T("JDN 0: \t%s\n"),
4345 wxDateTime(0.0).Format(fmt).c_str());
4346 wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
4347 wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
4348 wxPrintf(_T("May 29, 2099:\t%s\n"),
4349 wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
4350 }
4351
4352 static void TestTimeTicks()
4353 {
4354 wxPuts(_T("\n*** wxDateTime ticks test ***"));
4355
4356 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4357 {
4358 const Date& d = testDates[n];
4359 if ( d.ticks == -1 )
4360 continue;
4361
4362 wxDateTime dt = d.DT();
4363 long ticks = (dt.GetValue() / 1000).ToLong();
4364 wxPrintf(_T("Ticks of %s:\t% 10ld"), d.Format().c_str(), ticks);
4365 if ( ticks == d.ticks )
4366 {
4367 wxPuts(_T(" (ok)"));
4368 }
4369 else
4370 {
4371 wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
4372 (long)d.ticks, (long)(ticks - d.ticks));
4373 }
4374
4375 dt = d.DT().ToTimezone(wxDateTime::GMT0);
4376 ticks = (dt.GetValue() / 1000).ToLong();
4377 wxPrintf(_T("GMtks of %s:\t% 10ld"), d.Format().c_str(), ticks);
4378 if ( ticks == d.gmticks )
4379 {
4380 wxPuts(_T(" (ok)"));
4381 }
4382 else
4383 {
4384 wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
4385 (long)d.gmticks, (long)(ticks - d.gmticks));
4386 }
4387 }
4388
4389 wxPuts(_T(""));
4390 }
4391
4392 // test conversions to JDN &c
4393 static void TestTimeJDN()
4394 {
4395 wxPuts(_T("\n*** wxDateTime to JDN test ***"));
4396
4397 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4398 {
4399 const Date& d = testDates[n];
4400 wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
4401 double jdn = dt.GetJulianDayNumber();
4402
4403 wxPrintf(_T("JDN of %s is:\t% 15.6f"), d.Format().c_str(), jdn);
4404 if ( jdn == d.jdn )
4405 {
4406 wxPuts(_T(" (ok)"));
4407 }
4408 else
4409 {
4410 wxPrintf(_T(" (ERROR: should be %f, delta = %f)\n"),
4411 d.jdn, jdn - d.jdn);
4412 }
4413 }
4414 }
4415
4416 // test week days computation
4417 static void TestTimeWDays()
4418 {
4419 wxPuts(_T("\n*** wxDateTime weekday test ***"));
4420
4421 // test GetWeekDay()
4422 size_t n;
4423 for ( n = 0; n < WXSIZEOF(testDates); n++ )
4424 {
4425 const Date& d = testDates[n];
4426 wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
4427
4428 wxDateTime::WeekDay wday = dt.GetWeekDay();
4429 wxPrintf(_T("%s is: %s"),
4430 d.Format().c_str(),
4431 wxDateTime::GetWeekDayName(wday).c_str());
4432 if ( wday == d.wday )
4433 {
4434 wxPuts(_T(" (ok)"));
4435 }
4436 else
4437 {
4438 wxPrintf(_T(" (ERROR: should be %s)\n"),
4439 wxDateTime::GetWeekDayName(d.wday).c_str());
4440 }
4441 }
4442
4443 wxPuts(_T(""));
4444
4445 // test SetToWeekDay()
4446 struct WeekDateTestData
4447 {
4448 Date date; // the real date (precomputed)
4449 int nWeek; // its week index in the month
4450 wxDateTime::WeekDay wday; // the weekday
4451 wxDateTime::Month month; // the month
4452 int year; // and the year
4453
4454 wxString Format() const
4455 {
4456 wxString s, which;
4457 switch ( nWeek < -1 ? -nWeek : nWeek )
4458 {
4459 case 1: which = _T("first"); break;
4460 case 2: which = _T("second"); break;
4461 case 3: which = _T("third"); break;
4462 case 4: which = _T("fourth"); break;
4463 case 5: which = _T("fifth"); break;
4464
4465 case -1: which = _T("last"); break;
4466 }
4467
4468 if ( nWeek < -1 )
4469 {
4470 which += _T(" from end");
4471 }
4472
4473 s.Printf(_T("The %s %s of %s in %d"),
4474 which.c_str(),
4475 wxDateTime::GetWeekDayName(wday).c_str(),
4476 wxDateTime::GetMonthName(month).c_str(),
4477 year);
4478
4479 return s;
4480 }
4481 };
4482
4483 // the array data was generated by the following python program
4484 /*
4485 from DateTime import *
4486 from whrandom import *
4487 from string import *
4488
4489 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4490 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4491
4492 week = DateTimeDelta(7)
4493
4494 for n in range(20):
4495 year = randint(1900, 2100)
4496 month = randint(1, 12)
4497 day = randint(1, 28)
4498 dt = DateTime(year, month, day)
4499 wday = dt.day_of_week
4500
4501 countFromEnd = choice([-1, 1])
4502 weekNum = 0;
4503
4504 while dt.month is month:
4505 dt = dt - countFromEnd * week
4506 weekNum = weekNum + countFromEnd
4507
4508 data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
4509
4510 print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
4511 "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
4512 */
4513
4514 static const WeekDateTestData weekDatesTestData[] =
4515 {
4516 { { 20, wxDateTime::Mar, 2045 }, 3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
4517 { { 5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
4518 { { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
4519 { { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
4520 { { 4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
4521 { { 2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
4522 { { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
4523 { { 5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
4524 { { 11, wxDateTime::Aug, 1900 }, 2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
4525 { { 14, wxDateTime::Feb, 1945 }, 2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
4526 { { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
4527 { { 9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
4528 { { 20, wxDateTime::Jun, 1927 }, 3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
4529 { { 2, wxDateTime::Aug, 2000 }, 1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
4530 { { 20, wxDateTime::Apr, 2044 }, 3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
4531 { { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
4532 { { 25, wxDateTime::Jul, 2069 }, 4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
4533 { { 3, wxDateTime::Apr, 1925 }, 1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
4534 { { 21, wxDateTime::Mar, 2093 }, 3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
4535 { { 3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
4536 };
4537
4538 static const wxChar *fmt = _T("%d-%b-%Y");
4539
4540 wxDateTime dt;
4541 for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
4542 {
4543 const WeekDateTestData& wd = weekDatesTestData[n];
4544
4545 dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
4546
4547 wxPrintf(_T("%s is %s"), wd.Format().c_str(), dt.Format(fmt).c_str());
4548
4549 const Date& d = wd.date;
4550 if ( d.SameDay(dt.GetTm()) )
4551 {
4552 wxPuts(_T(" (ok)"));
4553 }
4554 else
4555 {
4556 dt.Set(d.day, d.month, d.year);
4557
4558 wxPrintf(_T(" (ERROR: should be %s)\n"), dt.Format(fmt).c_str());
4559 }
4560 }
4561 }
4562
4563 // test the computation of (ISO) week numbers
4564 static void TestTimeWNumber()
4565 {
4566 wxPuts(_T("\n*** wxDateTime week number test ***"));
4567
4568 struct WeekNumberTestData
4569 {
4570 Date date; // the date
4571 wxDateTime::wxDateTime_t week; // the week number in the year
4572 wxDateTime::wxDateTime_t wmon; // the week number in the month
4573 wxDateTime::wxDateTime_t wmon2; // same but week starts with Sun
4574 wxDateTime::wxDateTime_t dnum; // day number in the year
4575 };
4576
4577 // data generated with the following python script:
4578 /*
4579 from DateTime import *
4580 from whrandom import *
4581 from string import *
4582
4583 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4584 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4585
4586 def GetMonthWeek(dt):
4587 weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
4588 if weekNumMonth < 0:
4589 weekNumMonth = weekNumMonth + 53
4590 return weekNumMonth
4591
4592 def GetLastSundayBefore(dt):
4593 if dt.iso_week[2] == 7:
4594 return dt
4595 else:
4596 return dt - DateTimeDelta(dt.iso_week[2])
4597
4598 for n in range(20):
4599 year = randint(1900, 2100)
4600 month = randint(1, 12)
4601 day = randint(1, 28)
4602 dt = DateTime(year, month, day)
4603 dayNum = dt.day_of_year
4604 weekNum = dt.iso_week[1]
4605 weekNumMonth = GetMonthWeek(dt)
4606
4607 weekNumMonth2 = 0
4608 dtSunday = GetLastSundayBefore(dt)
4609
4610 while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
4611 weekNumMonth2 = weekNumMonth2 + 1
4612 dtSunday = dtSunday - DateTimeDelta(7)
4613
4614 data = { 'day': rjust(`day`, 2), \
4615 'month': monthNames[month - 1], \
4616 'year': year, \
4617 'weekNum': rjust(`weekNum`, 2), \
4618 'weekNumMonth': weekNumMonth, \
4619 'weekNumMonth2': weekNumMonth2, \
4620 'dayNum': rjust(`dayNum`, 3) }
4621
4622 print " { { %(day)s, "\
4623 "wxDateTime::%(month)s, "\
4624 "%(year)d }, "\
4625 "%(weekNum)s, "\
4626 "%(weekNumMonth)s, "\
4627 "%(weekNumMonth2)s, "\
4628 "%(dayNum)s }," % data
4629
4630 */
4631 static const WeekNumberTestData weekNumberTestDates[] =
4632 {
4633 { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
4634 { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
4635 { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
4636 { { 1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
4637 { { 8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
4638 { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4, 81 },
4639 { { 7, wxDateTime::Jan, 1965 }, 1, 2, 2, 7 },
4640 { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
4641 { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
4642 { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
4643 { { 2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
4644 { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
4645 { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
4646 { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
4647 { { 3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
4648 { { 23, wxDateTime::Feb, 1940 }, 8, 4, 4, 54 },
4649 { { 2, wxDateTime::Jan, 1987 }, 1, 1, 1, 2 },
4650 { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
4651 { { 2, wxDateTime::Feb, 2063 }, 5, 1, 1, 33 },
4652 { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
4653 };
4654
4655 for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
4656 {
4657 const WeekNumberTestData& wn = weekNumberTestDates[n];
4658 const Date& d = wn.date;
4659
4660 wxDateTime dt = d.DT();
4661
4662 wxDateTime::wxDateTime_t
4663 week = dt.GetWeekOfYear(wxDateTime::Monday_First),
4664 wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
4665 wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4666 dnum = dt.GetDayOfYear();
4667
4668 wxPrintf(_T("%s: the day number is %d"), d.FormatDate().c_str(), dnum);
4669 if ( dnum == wn.dnum )
4670 {
4671 wxPrintf(_T(" (ok)"));
4672 }
4673 else
4674 {
4675 wxPrintf(_T(" (ERROR: should be %d)"), wn.dnum);
4676 }
4677
4678 wxPrintf(_T(", week in month = %d"), wmon);
4679 if ( wmon != wn.wmon )
4680 {
4681 wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon);
4682 }
4683
4684 wxPrintf(_T(" or %d"), wmon2);
4685 if ( wmon2 == wn.wmon2 )
4686 {
4687 wxPrintf(_T(" (ok)"));
4688 }
4689 else
4690 {
4691 wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon2);
4692 }
4693
4694 wxPrintf(_T(", week in year = %d"), week);
4695 if ( week != wn.week )
4696 {
4697 wxPrintf(_T(" (ERROR: should be %d)"), wn.week);
4698 }
4699
4700 wxPutchar(_T('\n'));
4701
4702 wxDateTime dt2(1, wxDateTime::Jan, d.year);
4703 dt2.SetToTheWeek(wn.week, dt.GetWeekDay());
4704 if ( dt2 != dt )
4705 {
4706 Date d2;
4707 d2.Init(dt2.GetTm());
4708 wxPrintf(_T("ERROR: SetToTheWeek() returned %s\n"),
4709 d2.FormatDate().c_str());
4710 }
4711 }
4712 }
4713
4714 // test DST calculations
4715 static void TestTimeDST()
4716 {
4717 wxPuts(_T("\n*** wxDateTime DST test ***"));
4718
4719 wxPrintf(_T("DST is%s in effect now.\n\n"),
4720 wxDateTime::Now().IsDST() ? _T("") : _T(" not"));
4721
4722 // taken from http://www.energy.ca.gov/daylightsaving.html
4723 static const Date datesDST[2][2004 - 1900 + 1] =
4724 {
4725 {
4726 { 1, wxDateTime::Apr, 1990 },
4727 { 7, wxDateTime::Apr, 1991 },
4728 { 5, wxDateTime::Apr, 1992 },
4729 { 4, wxDateTime::Apr, 1993 },
4730 { 3, wxDateTime::Apr, 1994 },
4731 { 2, wxDateTime::Apr, 1995 },
4732 { 7, wxDateTime::Apr, 1996 },
4733 { 6, wxDateTime::Apr, 1997 },
4734 { 5, wxDateTime::Apr, 1998 },
4735 { 4, wxDateTime::Apr, 1999 },
4736 { 2, wxDateTime::Apr, 2000 },
4737 { 1, wxDateTime::Apr, 2001 },
4738 { 7, wxDateTime::Apr, 2002 },
4739 { 6, wxDateTime::Apr, 2003 },
4740 { 4, wxDateTime::Apr, 2004 },
4741 },
4742 {
4743 { 28, wxDateTime::Oct, 1990 },
4744 { 27, wxDateTime::Oct, 1991 },
4745 { 25, wxDateTime::Oct, 1992 },
4746 { 31, wxDateTime::Oct, 1993 },
4747 { 30, wxDateTime::Oct, 1994 },
4748 { 29, wxDateTime::Oct, 1995 },
4749 { 27, wxDateTime::Oct, 1996 },
4750 { 26, wxDateTime::Oct, 1997 },
4751 { 25, wxDateTime::Oct, 1998 },
4752 { 31, wxDateTime::Oct, 1999 },
4753 { 29, wxDateTime::Oct, 2000 },
4754 { 28, wxDateTime::Oct, 2001 },
4755 { 27, wxDateTime::Oct, 2002 },
4756 { 26, wxDateTime::Oct, 2003 },
4757 { 31, wxDateTime::Oct, 2004 },
4758 }
4759 };
4760
4761 int year;
4762 for ( year = 1990; year < 2005; year++ )
4763 {
4764 wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
4765 dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
4766
4767 wxPrintf(_T("DST period in the US for year %d: from %s to %s"),
4768 year, dtBegin.Format().c_str(), dtEnd.Format().c_str());
4769
4770 size_t n = year - 1990;
4771 const Date& dBegin = datesDST[0][n];
4772 const Date& dEnd = datesDST[1][n];
4773
4774 if ( dBegin.SameDay(dtBegin.GetTm()) && dEnd.SameDay(dtEnd.GetTm()) )
4775 {
4776 wxPuts(_T(" (ok)"));
4777 }
4778 else
4779 {
4780 wxPrintf(_T(" (ERROR: should be %s %d to %s %d)\n"),
4781 wxDateTime::GetMonthName(dBegin.month).c_str(), dBegin.day,
4782 wxDateTime::GetMonthName(dEnd.month).c_str(), dEnd.day);
4783 }
4784 }
4785
4786 wxPuts(_T(""));
4787
4788 for ( year = 1990; year < 2005; year++ )
4789 {
4790 wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
4791 year,
4792 wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
4793 wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
4794 }
4795 }
4796
4797 // test wxDateTime -> text conversion
4798 static void TestTimeFormat()
4799 {
4800 wxPuts(_T("\n*** wxDateTime formatting test ***"));
4801
4802 // some information may be lost during conversion, so store what kind
4803 // of info should we recover after a round trip
4804 enum CompareKind
4805 {
4806 CompareNone, // don't try comparing
4807 CompareBoth, // dates and times should be identical
4808 CompareDate, // dates only
4809 CompareTime // time only
4810 };
4811
4812 static const struct
4813 {
4814 CompareKind compareKind;
4815 const wxChar *format;
4816 } formatTestFormats[] =
4817 {
4818 { CompareBoth, _T("---> %c") },
4819 { CompareDate, _T("Date is %A, %d of %B, in year %Y") },
4820 { CompareBoth, _T("Date is %x, time is %X") },
4821 { CompareTime, _T("Time is %H:%M:%S or %I:%M:%S %p") },
4822 { CompareNone, _T("The day of year: %j, the week of year: %W") },
4823 { CompareDate, _T("ISO date without separators: %Y%m%d") },
4824 };
4825
4826 static const Date formatTestDates[] =
4827 {
4828 { 29, wxDateTime::May, 1976, 18, 30, 00 },
4829 { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
4830 #if 0
4831 // this test can't work for other centuries because it uses two digit
4832 // years in formats, so don't even try it
4833 { 29, wxDateTime::May, 2076, 18, 30, 00 },
4834 { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
4835 { 01, wxDateTime::Jan, -52, 03, 16, 47 },
4836 #endif
4837 };
4838
4839 // an extra test (as it doesn't depend on date, don't do it in the loop)
4840 wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
4841
4842 for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
4843 {
4844 wxPuts(_T(""));
4845
4846 wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
4847 for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
4848 {
4849 wxString s = dt.Format(formatTestFormats[n].format);
4850 wxPrintf(_T("%s"), s.c_str());
4851
4852 // what can we recover?
4853 int kind = formatTestFormats[n].compareKind;
4854
4855 // convert back
4856 wxDateTime dt2;
4857 const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
4858 if ( !result )
4859 {
4860 // converion failed - should it have?
4861 if ( kind == CompareNone )
4862 wxPuts(_T(" (ok)"));
4863 else
4864 wxPuts(_T(" (ERROR: conversion back failed)"));
4865 }
4866 else if ( *result )
4867 {
4868 // should have parsed the entire string
4869 wxPuts(_T(" (ERROR: conversion back stopped too soon)"));
4870 }
4871 else
4872 {
4873 bool equal = false; // suppress compilaer warning
4874 switch ( kind )
4875 {
4876 case CompareBoth:
4877 equal = dt2 == dt;
4878 break;
4879
4880 case CompareDate:
4881 equal = dt.IsSameDate(dt2);
4882 break;
4883
4884 case CompareTime:
4885 equal = dt.IsSameTime(dt2);
4886 break;
4887 }
4888
4889 if ( !equal )
4890 {
4891 wxPrintf(_T(" (ERROR: got back '%s' instead of '%s')\n"),
4892 dt2.Format().c_str(), dt.Format().c_str());
4893 }
4894 else
4895 {
4896 wxPuts(_T(" (ok)"));
4897 }
4898 }
4899 }
4900 }
4901 }
4902
4903 // test text -> wxDateTime conversion
4904 static void TestTimeParse()
4905 {
4906 wxPuts(_T("\n*** wxDateTime parse test ***"));
4907
4908 struct ParseTestData
4909 {
4910 const wxChar *format;
4911 Date date;
4912 bool good;
4913 };
4914
4915 static const ParseTestData parseTestDates[] =
4916 {
4917 { _T("Sat, 18 Dec 1999 00:46:40 +0100"), { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, true },
4918 { _T("Wed, 1 Dec 1999 05:17:20 +0300"), { 1, wxDateTime::Dec, 1999, 03, 17, 20 }, true },
4919 };
4920
4921 for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
4922 {
4923 const wxChar *format = parseTestDates[n].format;
4924
4925 wxPrintf(_T("%s => "), format);
4926
4927 wxDateTime dt;
4928 if ( dt.ParseRfc822Date(format) )
4929 {
4930 wxPrintf(_T("%s "), dt.Format().c_str());
4931
4932 if ( parseTestDates[n].good )
4933 {
4934 wxDateTime dtReal = parseTestDates[n].date.DT();
4935 if ( dt == dtReal )
4936 {
4937 wxPuts(_T("(ok)"));
4938 }
4939 else
4940 {
4941 wxPrintf(_T("(ERROR: should be %s)\n"), dtReal.Format().c_str());
4942 }
4943 }
4944 else
4945 {
4946 wxPuts(_T("(ERROR: bad format)"));
4947 }
4948 }
4949 else
4950 {
4951 wxPrintf(_T("bad format (%s)\n"),
4952 parseTestDates[n].good ? "ERROR" : "ok");
4953 }
4954 }
4955 }
4956
4957 static void TestDateTimeInteractive()
4958 {
4959 wxPuts(_T("\n*** interactive wxDateTime tests ***"));
4960
4961 wxChar buf[128];
4962
4963 for ( ;; )
4964 {
4965 wxPrintf(_T("Enter a date: "));
4966 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
4967 break;
4968
4969 // kill the last '\n'
4970 buf[wxStrlen(buf) - 1] = 0;
4971
4972 wxDateTime dt;
4973 const wxChar *p = dt.ParseDate(buf);
4974 if ( !p )
4975 {
4976 wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
4977
4978 continue;
4979 }
4980 else if ( *p )
4981 {
4982 wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
4983 }
4984
4985 wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
4986 dt.Format(_T("%b %d, %Y")).c_str(),
4987 dt.GetDayOfYear(),
4988 dt.GetWeekOfMonth(wxDateTime::Monday_First),
4989 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4990 dt.GetWeekOfYear(wxDateTime::Monday_First));
4991 }
4992
4993 wxPuts(_T("\n*** done ***"));
4994 }
4995
4996 static void TestTimeMS()
4997 {
4998 wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
4999
5000 wxDateTime dt1 = wxDateTime::Now(),
5001 dt2 = wxDateTime::UNow();
5002
5003 wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
5004 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
5005 wxPrintf(_T("Dummy loop: "));
5006 for ( int i = 0; i < 6000; i++ )
5007 {
5008 //for ( int j = 0; j < 10; j++ )
5009 {
5010 wxString s;
5011 s.Printf(_T("%g"), sqrt(i));
5012 }
5013
5014 if ( !(i % 100) )
5015 putchar('.');
5016 }
5017 wxPuts(_T(", done"));
5018
5019 dt1 = dt2;
5020 dt2 = wxDateTime::UNow();
5021 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
5022
5023 wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
5024
5025 wxPuts(_T("\n*** done ***"));
5026 }
5027
5028 static void TestTimeArithmetics()
5029 {
5030 wxPuts(_T("\n*** testing arithmetic operations on wxDateTime ***"));
5031
5032 static const struct ArithmData
5033 {
5034 ArithmData(const wxDateSpan& sp, const wxChar *nam)
5035 : span(sp), name(nam) { }
5036
5037 wxDateSpan span;
5038 const wxChar *name;
5039 } testArithmData[] =
5040 {
5041 ArithmData(wxDateSpan::Day(), _T("day")),
5042 ArithmData(wxDateSpan::Week(), _T("week")),
5043 ArithmData(wxDateSpan::Month(), _T("month")),
5044 ArithmData(wxDateSpan::Year(), _T("year")),
5045 ArithmData(wxDateSpan(1, 2, 3, 4), _T("year, 2 months, 3 weeks, 4 days")),
5046 };
5047
5048 wxDateTime dt(29, wxDateTime::Dec, 1999), dt1, dt2;
5049
5050 for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
5051 {
5052 wxDateSpan span = testArithmData[n].span;
5053 dt1 = dt + span;
5054 dt2 = dt - span;
5055
5056 const wxChar *name = testArithmData[n].name;
5057 wxPrintf(_T("%s + %s = %s, %s - %s = %s\n"),
5058 dt.FormatISODate().c_str(), name, dt1.FormatISODate().c_str(),
5059 dt.FormatISODate().c_str(), name, dt2.FormatISODate().c_str());
5060
5061 wxPrintf(_T("Going back: %s"), (dt1 - span).FormatISODate().c_str());
5062 if ( dt1 - span == dt )
5063 {
5064 wxPuts(_T(" (ok)"));
5065 }
5066 else
5067 {
5068 wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
5069 }
5070
5071 wxPrintf(_T("Going forward: %s"), (dt2 + span).FormatISODate().c_str());
5072 if ( dt2 + span == dt )
5073 {
5074 wxPuts(_T(" (ok)"));
5075 }
5076 else
5077 {
5078 wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
5079 }
5080
5081 wxPrintf(_T("Double increment: %s"), (dt2 + 2*span).FormatISODate().c_str());
5082 if ( dt2 + 2*span == dt1 )
5083 {
5084 wxPuts(_T(" (ok)"));
5085 }
5086 else
5087 {
5088 wxPrintf(_T(" (ERROR: should be %s)\n"), dt2.FormatISODate().c_str());
5089 }
5090
5091 wxPuts(_T(""));
5092 }
5093 }
5094
5095 static void TestTimeHolidays()
5096 {
5097 wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
5098
5099 wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
5100 wxDateTime dtStart(1, tm.mon, tm.year),
5101 dtEnd = dtStart.GetLastMonthDay();
5102
5103 wxDateTimeArray hol;
5104 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
5105
5106 const wxChar *format = _T("%d-%b-%Y (%a)");
5107
5108 wxPrintf(_T("All holidays between %s and %s:\n"),
5109 dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
5110
5111 size_t count = hol.GetCount();
5112 for ( size_t n = 0; n < count; n++ )
5113 {
5114 wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
5115 }
5116
5117 wxPuts(_T(""));
5118 }
5119
5120 static void TestTimeZoneBug()
5121 {
5122 wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
5123
5124 wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
5125 for ( int i = 0; i < 31; i++ )
5126 {
5127 wxPrintf(_T("Date %s: week day %s.\n"),
5128 date.Format(_T("%d-%m-%Y")).c_str(),
5129 date.GetWeekDayName(date.GetWeekDay()).c_str());
5130
5131 date += wxDateSpan::Day();
5132 }
5133
5134 wxPuts(_T(""));
5135 }
5136
5137 static void TestTimeSpanFormat()
5138 {
5139 wxPuts(_T("\n*** wxTimeSpan tests ***"));
5140
5141 static const wxChar *formats[] =
5142 {
5143 _T("(default) %H:%M:%S"),
5144 _T("%E weeks and %D days"),
5145 _T("%l milliseconds"),
5146 _T("(with ms) %H:%M:%S:%l"),
5147 _T("100%% of minutes is %M"), // test "%%"
5148 _T("%D days and %H hours"),
5149 _T("or also %S seconds"),
5150 };
5151
5152 wxTimeSpan ts1(1, 2, 3, 4),
5153 ts2(111, 222, 333);
5154 for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
5155 {
5156 wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
5157 ts1.Format(formats[n]).c_str(),
5158 ts2.Format(formats[n]).c_str());
5159 }
5160
5161 wxPuts(_T(""));
5162 }
5163
5164 #endif // TEST_DATETIME
5165
5166 // ----------------------------------------------------------------------------
5167 // wxTextInput/OutputStream
5168 // ----------------------------------------------------------------------------
5169
5170 #ifdef TEST_TEXTSTREAM
5171
5172 #include "wx/txtstrm.h"
5173 #include "wx/wfstream.h"
5174
5175 static void TestTextInputStream()
5176 {
5177 wxPuts(_T("\n*** wxTextInputStream test ***"));
5178
5179 wxFileInputStream fsIn(_T("testdata.fc"));
5180 if ( !fsIn.Ok() )
5181 {
5182 wxPuts(_T("ERROR: couldn't open file."));
5183 }
5184 else
5185 {
5186 wxTextInputStream tis(fsIn);
5187
5188 size_t line = 1;
5189 for ( ;; )
5190 {
5191 const wxString s = tis.ReadLine();
5192
5193 // line could be non empty if the last line of the file isn't
5194 // terminated with EOL
5195 if ( fsIn.Eof() && s.empty() )
5196 break;
5197
5198 wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
5199 }
5200 }
5201 }
5202
5203 #endif // TEST_TEXTSTREAM
5204
5205 // ----------------------------------------------------------------------------
5206 // threads
5207 // ----------------------------------------------------------------------------
5208
5209 #ifdef TEST_THREADS
5210
5211 #include "wx/thread.h"
5212
5213 static size_t gs_counter = (size_t)-1;
5214 static wxCriticalSection gs_critsect;
5215 static wxSemaphore gs_cond;
5216
5217 class MyJoinableThread : public wxThread
5218 {
5219 public:
5220 MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
5221 { m_n = n; Create(); }
5222
5223 // thread execution starts here
5224 virtual ExitCode Entry();
5225
5226 private:
5227 size_t m_n;
5228 };
5229
5230 wxThread::ExitCode MyJoinableThread::Entry()
5231 {
5232 unsigned long res = 1;
5233 for ( size_t n = 1; n < m_n; n++ )
5234 {
5235 res *= n;
5236
5237 // it's a loooong calculation :-)
5238 Sleep(100);
5239 }
5240
5241 return (ExitCode)res;
5242 }
5243
5244 class MyDetachedThread : public wxThread
5245 {
5246 public:
5247 MyDetachedThread(size_t n, wxChar ch)
5248 {
5249 m_n = n;
5250 m_ch = ch;
5251 m_cancelled = false;
5252
5253 Create();
5254 }
5255
5256 // thread execution starts here
5257 virtual ExitCode Entry();
5258
5259 // and stops here
5260 virtual void OnExit();
5261
5262 private:
5263 size_t m_n; // number of characters to write
5264 wxChar m_ch; // character to write
5265
5266 bool m_cancelled; // false if we exit normally
5267 };
5268
5269 wxThread::ExitCode MyDetachedThread::Entry()
5270 {
5271 {
5272 wxCriticalSectionLocker lock(gs_critsect);
5273 if ( gs_counter == (size_t)-1 )
5274 gs_counter = 1;
5275 else
5276 gs_counter++;
5277 }
5278
5279 for ( size_t n = 0; n < m_n; n++ )
5280 {
5281 if ( TestDestroy() )
5282 {
5283 m_cancelled = true;
5284
5285 break;
5286 }
5287
5288 putchar(m_ch);
5289 fflush(stdout);
5290
5291 wxThread::Sleep(100);
5292 }
5293
5294 return 0;
5295 }
5296
5297 void MyDetachedThread::OnExit()
5298 {
5299 wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
5300
5301 wxCriticalSectionLocker lock(gs_critsect);
5302 if ( !--gs_counter && !m_cancelled )
5303 gs_cond.Post();
5304 }
5305
5306 static void TestDetachedThreads()
5307 {
5308 wxPuts(_T("\n*** Testing detached threads ***"));
5309
5310 static const size_t nThreads = 3;
5311 MyDetachedThread *threads[nThreads];
5312 size_t n;
5313 for ( n = 0; n < nThreads; n++ )
5314 {
5315 threads[n] = new MyDetachedThread(10, 'A' + n);
5316 }
5317
5318 threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
5319 threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
5320
5321 for ( n = 0; n < nThreads; n++ )
5322 {
5323 threads[n]->Run();
5324 }
5325
5326 // wait until all threads terminate
5327 gs_cond.Wait();
5328
5329 wxPuts(_T(""));
5330 }
5331
5332 static void TestJoinableThreads()
5333 {
5334 wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
5335
5336 // calc 10! in the background
5337 MyJoinableThread thread(10);
5338 thread.Run();
5339
5340 wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
5341 (unsigned long)thread.Wait());
5342 }
5343
5344 static void TestThreadSuspend()
5345 {
5346 wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
5347
5348 MyDetachedThread *thread = new MyDetachedThread(15, 'X');
5349
5350 thread->Run();
5351
5352 // this is for this demo only, in a real life program we'd use another
5353 // condition variable which would be signaled from wxThread::Entry() to
5354 // tell us that the thread really started running - but here just wait a
5355 // bit and hope that it will be enough (the problem is, of course, that
5356 // the thread might still not run when we call Pause() which will result
5357 // in an error)
5358 wxThread::Sleep(300);
5359
5360 for ( size_t n = 0; n < 3; n++ )
5361 {
5362 thread->Pause();
5363
5364 wxPuts(_T("\nThread suspended"));
5365 if ( n > 0 )
5366 {
5367 // don't sleep but resume immediately the first time
5368 wxThread::Sleep(300);
5369 }
5370 wxPuts(_T("Going to resume the thread"));
5371
5372 thread->Resume();
5373 }
5374
5375 wxPuts(_T("Waiting until it terminates now"));
5376
5377 // wait until the thread terminates
5378 gs_cond.Wait();
5379
5380 wxPuts(_T(""));
5381 }
5382
5383 static void TestThreadDelete()
5384 {
5385 // As above, using Sleep() is only for testing here - we must use some
5386 // synchronisation object instead to ensure that the thread is still
5387 // running when we delete it - deleting a detached thread which already
5388 // terminated will lead to a crash!
5389
5390 wxPuts(_T("\n*** Testing thread delete function ***"));
5391
5392 MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
5393
5394 thread0->Delete();
5395
5396 wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
5397
5398 MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
5399
5400 thread1->Run();
5401
5402 wxThread::Sleep(300);
5403
5404 thread1->Delete();
5405
5406 wxPuts(_T("\nDeleted a running thread."));
5407
5408 MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
5409
5410 thread2->Run();
5411
5412 wxThread::Sleep(300);
5413
5414 thread2->Pause();
5415
5416 thread2->Delete();
5417
5418 wxPuts(_T("\nDeleted a sleeping thread."));
5419
5420 MyJoinableThread thread3(20);
5421 thread3.Run();
5422
5423 thread3.Delete();
5424
5425 wxPuts(_T("\nDeleted a joinable thread."));
5426
5427 MyJoinableThread thread4(2);
5428 thread4.Run();
5429
5430 wxThread::Sleep(300);
5431
5432 thread4.Delete();
5433
5434 wxPuts(_T("\nDeleted a joinable thread which already terminated."));
5435
5436 wxPuts(_T(""));
5437 }
5438
5439 class MyWaitingThread : public wxThread
5440 {
5441 public:
5442 MyWaitingThread( wxMutex *mutex, wxCondition *condition )
5443 {
5444 m_mutex = mutex;
5445 m_condition = condition;
5446
5447 Create();
5448 }
5449
5450 virtual ExitCode Entry()
5451 {
5452 wxPrintf(_T("Thread %lu has started running.\n"), GetId());
5453 fflush(stdout);
5454
5455 gs_cond.Post();
5456
5457 wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
5458 fflush(stdout);
5459
5460 m_mutex->Lock();
5461 m_condition->Wait();
5462 m_mutex->Unlock();
5463
5464 wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
5465 fflush(stdout);
5466
5467 return 0;
5468 }
5469
5470 private:
5471 wxMutex *m_mutex;
5472 wxCondition *m_condition;
5473 };
5474
5475 static void TestThreadConditions()
5476 {
5477 wxMutex mutex;
5478 wxCondition condition(mutex);
5479
5480 // otherwise its difficult to understand which log messages pertain to
5481 // which condition
5482 //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
5483 // condition.GetId(), gs_cond.GetId());
5484
5485 // create and launch threads
5486 MyWaitingThread *threads[10];
5487
5488 size_t n;
5489 for ( n = 0; n < WXSIZEOF(threads); n++ )
5490 {
5491 threads[n] = new MyWaitingThread( &mutex, &condition );
5492 }
5493
5494 for ( n = 0; n < WXSIZEOF(threads); n++ )
5495 {
5496 threads[n]->Run();
5497 }
5498
5499 // wait until all threads run
5500 wxPuts(_T("Main thread is waiting for the other threads to start"));
5501 fflush(stdout);
5502
5503 size_t nRunning = 0;
5504 while ( nRunning < WXSIZEOF(threads) )
5505 {
5506 gs_cond.Wait();
5507
5508 nRunning++;
5509
5510 wxPrintf(_T("Main thread: %u already running\n"), nRunning);
5511 fflush(stdout);
5512 }
5513
5514 wxPuts(_T("Main thread: all threads started up."));
5515 fflush(stdout);
5516
5517 wxThread::Sleep(500);
5518
5519 #if 1
5520 // now wake one of them up
5521 wxPrintf(_T("Main thread: about to signal the condition.\n"));
5522 fflush(stdout);
5523 condition.Signal();
5524 #endif
5525
5526 wxThread::Sleep(200);
5527
5528 // wake all the (remaining) threads up, so that they can exit
5529 wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
5530 fflush(stdout);
5531 condition.Broadcast();
5532
5533 // give them time to terminate (dirty!)
5534 wxThread::Sleep(500);
5535 }
5536
5537 #include "wx/utils.h"
5538
5539 class MyExecThread : public wxThread
5540 {
5541 public:
5542 MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
5543 m_command(command)
5544 {
5545 Create();
5546 }
5547
5548 virtual ExitCode Entry()
5549 {
5550 return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
5551 }
5552
5553 private:
5554 wxString m_command;
5555 };
5556
5557 static void TestThreadExec()
5558 {
5559 wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
5560
5561 MyExecThread thread(_T("true"));
5562 thread.Run();
5563
5564 wxPrintf(_T("Main program exit code: %ld.\n"),
5565 wxExecute(_T("false"), wxEXEC_SYNC));
5566
5567 wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
5568 }
5569
5570 // semaphore tests
5571 #include "wx/datetime.h"
5572
5573 class MySemaphoreThread : public wxThread
5574 {
5575 public:
5576 MySemaphoreThread(int i, wxSemaphore *sem)
5577 : wxThread(wxTHREAD_JOINABLE),
5578 m_sem(sem),
5579 m_i(i)
5580 {
5581 Create();
5582 }
5583
5584 virtual ExitCode Entry()
5585 {
5586 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
5587 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5588
5589 m_sem->Wait();
5590
5591 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
5592 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5593
5594 Sleep(1000);
5595
5596 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
5597 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5598
5599 m_sem->Post();
5600
5601 return 0;
5602 }
5603
5604 private:
5605 wxSemaphore *m_sem;
5606 int m_i;
5607 };
5608
5609 WX_DEFINE_ARRAY(wxThread *, ArrayThreads);
5610
5611 static void TestSemaphore()
5612 {
5613 wxPuts(_T("*** Testing wxSemaphore class. ***"));
5614
5615 static const int SEM_LIMIT = 3;
5616
5617 wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
5618 ArrayThreads threads;
5619
5620 for ( int i = 0; i < 3*SEM_LIMIT; i++ )
5621 {
5622 threads.Add(new MySemaphoreThread(i, &sem));
5623 threads.Last()->Run();
5624 }
5625
5626 for ( size_t n = 0; n < threads.GetCount(); n++ )
5627 {
5628 threads[n]->Wait();
5629 delete threads[n];
5630 }
5631 }
5632
5633 #endif // TEST_THREADS
5634
5635 // ----------------------------------------------------------------------------
5636 // arrays
5637 // ----------------------------------------------------------------------------
5638
5639 #ifdef TEST_ARRAYS
5640
5641 #include "wx/dynarray.h"
5642
5643 typedef unsigned short ushort;
5644
5645 #define DefineCompare(name, T) \
5646 \
5647 int wxCMPFUNC_CONV name ## CompareValues(T first, T second) \
5648 { \
5649 return first - second; \
5650 } \
5651 \
5652 int wxCMPFUNC_CONV name ## Compare(T* first, T* second) \
5653 { \
5654 return *first - *second; \
5655 } \
5656 \
5657 int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second) \
5658 { \
5659 return *second - *first; \
5660 } \
5661
5662 DefineCompare(UShort, ushort);
5663 DefineCompare(Int, int);
5664
5665 // test compilation of all macros
5666 WX_DEFINE_ARRAY_SHORT(ushort, wxArrayUShort);
5667 WX_DEFINE_SORTED_ARRAY_SHORT(ushort, wxSortedArrayUShortNoCmp);
5668 WX_DEFINE_SORTED_ARRAY_CMP_SHORT(ushort, UShortCompareValues, wxSortedArrayUShort);
5669 WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt);
5670
5671 WX_DECLARE_OBJARRAY(Bar, ArrayBars);
5672 #include "wx/arrimpl.cpp"
5673 WX_DEFINE_OBJARRAY(ArrayBars);
5674
5675 static void PrintArray(const wxChar* name, const wxArrayString& array)
5676 {
5677 wxPrintf(_T("Dump of the array '%s'\n"), name);
5678
5679 size_t nCount = array.GetCount();
5680 for ( size_t n = 0; n < nCount; n++ )
5681 {
5682 wxPrintf(_T("\t%s[%u] = '%s'\n"), name, n, array[n].c_str());
5683 }
5684 }
5685
5686 int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
5687 const wxString& second)
5688 {
5689 return first.length() - second.length();
5690 }
5691
5692 #define TestArrayOf(name) \
5693 \
5694 static void PrintArray(const wxChar* name, const wxSortedArray##name & array) \
5695 { \
5696 wxPrintf(_T("Dump of the array '%s'\n"), name); \
5697 \
5698 size_t nCount = array.GetCount(); \
5699 for ( size_t n = 0; n < nCount; n++ ) \
5700 { \
5701 wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]); \
5702 } \
5703 } \
5704 \
5705 static void PrintArray(const wxChar* name, const wxArray##name & array) \
5706 { \
5707 wxPrintf(_T("Dump of the array '%s'\n"), name); \
5708 \
5709 size_t nCount = array.GetCount(); \
5710 for ( size_t n = 0; n < nCount; n++ ) \
5711 { \
5712 wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]); \
5713 } \
5714 } \
5715 \
5716 static void TestArrayOf ## name ## s() \
5717 { \
5718 wxPrintf(_T("*** Testing wxArray%s ***\n"), #name); \
5719 \
5720 wxArray##name a; \
5721 a.Add(1); \
5722 a.Add(17,2); \
5723 a.Add(5,3); \
5724 a.Add(3,4); \
5725 \
5726 wxPuts(_T("Initially:")); \
5727 PrintArray(_T("a"), a); \
5728 \
5729 wxPuts(_T("After sort:")); \
5730 a.Sort(name ## Compare); \
5731 PrintArray(_T("a"), a); \
5732 \
5733 wxPuts(_T("After reverse sort:")); \
5734 a.Sort(name ## RevCompare); \
5735 PrintArray(_T("a"), a); \
5736 \
5737 wxSortedArray##name b; \
5738 b.Add(1); \
5739 b.Add(17); \
5740 b.Add(5); \
5741 b.Add(3); \
5742 \
5743 wxPuts(_T("Sorted array initially:")); \
5744 PrintArray(_T("b"), b); \
5745 }
5746
5747 TestArrayOf(UShort);
5748 TestArrayOf(Int);
5749
5750 static void TestArrayOfObjects()
5751 {
5752 wxPuts(_T("*** Testing wxObjArray ***\n"));
5753
5754 {
5755 ArrayBars bars;
5756 Bar bar("second bar (two copies!)");
5757
5758 wxPrintf(_T("Initially: %u objects in the array, %u objects total.\n"),
5759 bars.GetCount(), Bar::GetNumber());
5760
5761 bars.Add(new Bar("first bar"));
5762 bars.Add(bar,2);
5763
5764 wxPrintf(_T("Now: %u objects in the array, %u objects total.\n"),
5765 bars.GetCount(), Bar::GetNumber());
5766
5767 bars.RemoveAt(1, bars.GetCount() - 1);
5768
5769 wxPrintf(_T("After removing all but first element: %u objects in the ")
5770 _T("array, %u objects total.\n"),
5771 bars.GetCount(), Bar::GetNumber());
5772
5773 bars.Empty();
5774
5775 wxPrintf(_T("After Empty(): %u objects in the array, %u objects total.\n"),
5776 bars.GetCount(), Bar::GetNumber());
5777 }
5778
5779 wxPrintf(_T("Finally: no more objects in the array, %u objects total.\n"),
5780 Bar::GetNumber());
5781 }
5782
5783 #endif // TEST_ARRAYS
5784
5785 // ----------------------------------------------------------------------------
5786 // strings
5787 // ----------------------------------------------------------------------------
5788
5789 #ifdef TEST_STRINGS
5790
5791 #include "wx/timer.h"
5792 #include "wx/tokenzr.h"
5793
5794 static void TestStringConstruction()
5795 {
5796 wxPuts(_T("*** Testing wxString constructores ***"));
5797
5798 #define TEST_CTOR(args, res) \
5799 { \
5800 wxString s args ; \
5801 wxPrintf(_T("wxString%s = %s "), #args, s.c_str()); \
5802 if ( s == res ) \
5803 { \
5804 wxPuts(_T("(ok)")); \
5805 } \
5806 else \
5807 { \
5808 wxPrintf(_T("(ERROR: should be %s)\n"), res); \
5809 } \
5810 }
5811
5812 TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
5813 TEST_CTOR((_T("Hello"), 4), _T("Hell"));
5814 TEST_CTOR((_T("Hello"), 5), _T("Hello"));
5815 // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
5816
5817 static const wxChar *s = _T("?really!");
5818 const wxChar *start = wxStrchr(s, _T('r'));
5819 const wxChar *end = wxStrchr(s, _T('!'));
5820 TEST_CTOR((start, end), _T("really"));
5821
5822 wxPuts(_T(""));
5823 }
5824
5825 static void TestString()
5826 {
5827 wxStopWatch sw;
5828
5829 wxString a, b, c;
5830
5831 a.reserve (128);
5832 b.reserve (128);
5833 c.reserve (128);
5834
5835 for (int i = 0; i < 1000000; ++i)
5836 {
5837 a = "Hello";
5838 b = " world";
5839 c = "! How'ya doin'?";
5840 a += b;
5841 a += c;
5842 c = "Hello world! What's up?";
5843 if (c != a)
5844 c = "Doh!";
5845 }
5846
5847 wxPrintf(_T("TestString elapsed time: %ld\n"), sw.Time());
5848 }
5849
5850 static void TestPChar()
5851 {
5852 wxStopWatch sw;
5853
5854 wxChar a [128];
5855 wxChar b [128];
5856 wxChar c [128];
5857
5858 for (int i = 0; i < 1000000; ++i)
5859 {
5860 wxStrcpy (a, _T("Hello"));
5861 wxStrcpy (b, _T(" world"));
5862 wxStrcpy (c, _T("! How'ya doin'?"));
5863 wxStrcat (a, b);
5864 wxStrcat (a, c);
5865 wxStrcpy (c, _T("Hello world! What's up?"));
5866 if (wxStrcmp (c, a) == 0)
5867 wxStrcpy (c, _T("Doh!"));
5868 }
5869
5870 wxPrintf(_T("TestPChar elapsed time: %ld\n"), sw.Time());
5871 }
5872
5873 static void TestStringSub()
5874 {
5875 wxString s("Hello, world!");
5876
5877 wxPuts(_T("*** Testing wxString substring extraction ***"));
5878
5879 wxPrintf(_T("String = '%s'\n"), s.c_str());
5880 wxPrintf(_T("Left(5) = '%s'\n"), s.Left(5).c_str());
5881 wxPrintf(_T("Right(6) = '%s'\n"), s.Right(6).c_str());
5882 wxPrintf(_T("Mid(3, 5) = '%s'\n"), s(3, 5).c_str());
5883 wxPrintf(_T("Mid(3) = '%s'\n"), s.Mid(3).c_str());
5884 wxPrintf(_T("substr(3, 5) = '%s'\n"), s.substr(3, 5).c_str());
5885 wxPrintf(_T("substr(3) = '%s'\n"), s.substr(3).c_str());
5886
5887 static const wxChar *prefixes[] =
5888 {
5889 _T("Hello"),
5890 _T("Hello, "),
5891 _T("Hello, world!"),
5892 _T("Hello, world!!!"),
5893 _T(""),
5894 _T("Goodbye"),
5895 _T("Hi"),
5896 };
5897
5898 for ( size_t n = 0; n < WXSIZEOF(prefixes); n++ )
5899 {
5900 wxString prefix = prefixes[n], rest;
5901 bool rc = s.StartsWith(prefix, &rest);
5902 wxPrintf(_T("StartsWith('%s') = %s"), prefix.c_str(), rc ? _T("true") : _T("false"));
5903 if ( rc )
5904 {
5905 wxPrintf(_T(" (the rest is '%s')\n"), rest.c_str());
5906 }
5907 else
5908 {
5909 putchar('\n');
5910 }
5911 }
5912
5913 wxPuts(_T(""));
5914 }
5915
5916 static void TestStringFormat()
5917 {
5918 wxPuts(_T("*** Testing wxString formatting ***"));
5919
5920 wxString s;
5921 s.Printf(_T("%03d"), 18);
5922
5923 wxPrintf(_T("Number 18: %s\n"), wxString::Format(_T("%03d"), 18).c_str());
5924 wxPrintf(_T("Number 18: %s\n"), s.c_str());
5925
5926 wxPuts(_T(""));
5927 }
5928
5929 // returns "not found" for npos, value for all others
5930 static wxString PosToString(size_t res)
5931 {
5932 wxString s = res == wxString::npos ? wxString(_T("not found"))
5933 : wxString::Format(_T("%u"), res);
5934 return s;
5935 }
5936
5937 static void TestStringFind()
5938 {
5939 wxPuts(_T("*** Testing wxString find() functions ***"));
5940
5941 static const wxChar *strToFind = _T("ell");
5942 static const struct StringFindTest
5943 {
5944 const wxChar *str;
5945 size_t start,
5946 result; // of searching "ell" in str
5947 } findTestData[] =
5948 {
5949 { _T("Well, hello world"), 0, 1 },
5950 { _T("Well, hello world"), 6, 7 },
5951 { _T("Well, hello world"), 9, wxString::npos },
5952 };
5953
5954 for ( size_t n = 0; n < WXSIZEOF(findTestData); n++ )
5955 {
5956 const StringFindTest& ft = findTestData[n];
5957 size_t res = wxString(ft.str).find(strToFind, ft.start);
5958
5959 wxPrintf(_T("Index of '%s' in '%s' starting from %u is %s "),
5960 strToFind, ft.str, ft.start, PosToString(res).c_str());
5961
5962 size_t resTrue = ft.result;
5963 if ( res == resTrue )
5964 {
5965 wxPuts(_T("(ok)"));
5966 }
5967 else
5968 {
5969 wxPrintf(_T("(ERROR: should be %s)\n"),
5970 PosToString(resTrue).c_str());
5971 }
5972 }
5973
5974 wxPuts(_T(""));
5975 }
5976
5977 static void TestStringTokenizer()
5978 {
5979 wxPuts(_T("*** Testing wxStringTokenizer ***"));
5980
5981 static const wxChar *modeNames[] =
5982 {
5983 _T("default"),
5984 _T("return empty"),
5985 _T("return all empty"),
5986 _T("with delims"),
5987 _T("like strtok"),
5988 };
5989
5990 static const struct StringTokenizerTest
5991 {
5992 const wxChar *str; // string to tokenize
5993 const wxChar *delims; // delimiters to use
5994 size_t count; // count of token
5995 wxStringTokenizerMode mode; // how should we tokenize it
5996 } tokenizerTestData[] =
5997 {
5998 { _T(""), _T(" "), 0 },
5999 { _T("Hello, world"), _T(" "), 2 },
6000 { _T("Hello, world "), _T(" "), 2 },
6001 { _T("Hello, world"), _T(","), 2 },
6002 { _T("Hello, world!"), _T(",!"), 2 },
6003 { _T("Hello,, world!"), _T(",!"), 3 },
6004 { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL },
6005 { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
6006 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 4 },
6007 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY },
6008 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL },
6009 { _T("01/02/99"), _T("/-"), 3 },
6010 { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS },
6011 };
6012
6013 for ( size_t n = 0; n < WXSIZEOF(tokenizerTestData); n++ )
6014 {
6015 const StringTokenizerTest& tt = tokenizerTestData[n];
6016 wxStringTokenizer tkz(tt.str, tt.delims, tt.mode);
6017
6018 size_t count = tkz.CountTokens();
6019 wxPrintf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
6020 MakePrintable(tt.str).c_str(),
6021 count,
6022 MakePrintable(tt.delims).c_str(),
6023 modeNames[tkz.GetMode()]);
6024 if ( count == tt.count )
6025 {
6026 wxPuts(_T("(ok)"));
6027 }
6028 else
6029 {
6030 wxPrintf(_T("(ERROR: should be %u)\n"), tt.count);
6031
6032 continue;
6033 }
6034
6035 // if we emulate strtok(), check that we do it correctly
6036 wxChar *buf, *s = NULL, *last;
6037
6038 if ( tkz.GetMode() == wxTOKEN_STRTOK )
6039 {
6040 buf = new wxChar[wxStrlen(tt.str) + 1];
6041 wxStrcpy(buf, tt.str);
6042
6043 s = wxStrtok(buf, tt.delims, &last);
6044 }
6045 else
6046 {
6047 buf = NULL;
6048 }
6049
6050 // now show the tokens themselves
6051 size_t count2 = 0;
6052 while ( tkz.HasMoreTokens() )
6053 {
6054 wxString token = tkz.GetNextToken();
6055
6056 wxPrintf(_T("\ttoken %u: '%s'"),
6057 ++count2,
6058 MakePrintable(token).c_str());
6059
6060 if ( buf )
6061 {
6062 if ( token == s )
6063 {
6064 wxPuts(_T(" (ok)"));
6065 }
6066 else
6067 {
6068 wxPrintf(_T(" (ERROR: should be %s)\n"), s);
6069 }
6070
6071 s = wxStrtok(NULL, tt.delims, &last);
6072 }
6073 else
6074 {
6075 // nothing to compare with
6076 wxPuts(_T(""));
6077 }
6078 }
6079
6080 if ( count2 != count )
6081 {
6082 wxPuts(_T("\tERROR: token count mismatch"));
6083 }
6084
6085 delete [] buf;
6086 }
6087
6088 wxPuts(_T(""));
6089 }
6090
6091 static void TestStringReplace()
6092 {
6093 wxPuts(_T("*** Testing wxString::replace ***"));
6094
6095 static const struct StringReplaceTestData
6096 {
6097 const wxChar *original; // original test string
6098 size_t start, len; // the part to replace
6099 const wxChar *replacement; // the replacement string
6100 const wxChar *result; // and the expected result
6101 } stringReplaceTestData[] =
6102 {
6103 { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
6104 { _T("increase"), 0, 2, _T("de"), _T("decrease") },
6105 { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
6106 { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
6107 { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
6108 };
6109
6110 for ( size_t n = 0; n < WXSIZEOF(stringReplaceTestData); n++ )
6111 {
6112 const StringReplaceTestData data = stringReplaceTestData[n];
6113
6114 wxString original = data.original;
6115 original.replace(data.start, data.len, data.replacement);
6116
6117 wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
6118 data.original, data.start, data.len, data.replacement,
6119 original.c_str());
6120
6121 if ( original == data.result )
6122 {
6123 wxPuts(_T("(ok)"));
6124 }
6125 else
6126 {
6127 wxPrintf(_T("(ERROR: should be '%s')\n"), data.result);
6128 }
6129 }
6130
6131 wxPuts(_T(""));
6132 }
6133
6134 static void TestStringMatch()
6135 {
6136 wxPuts(_T("*** Testing wxString::Matches() ***"));
6137
6138 static const struct StringMatchTestData
6139 {
6140 const wxChar *text;
6141 const wxChar *wildcard;
6142 bool matches;
6143 } stringMatchTestData[] =
6144 {
6145 { _T("foobar"), _T("foo*"), 1 },
6146 { _T("foobar"), _T("*oo*"), 1 },
6147 { _T("foobar"), _T("*bar"), 1 },
6148 { _T("foobar"), _T("??????"), 1 },
6149 { _T("foobar"), _T("f??b*"), 1 },
6150 { _T("foobar"), _T("f?b*"), 0 },
6151 { _T("foobar"), _T("*goo*"), 0 },
6152 { _T("foobar"), _T("*foo"), 0 },
6153 { _T("foobarfoo"), _T("*foo"), 1 },
6154 { _T(""), _T("*"), 1 },
6155 { _T(""), _T("?"), 0 },
6156 };
6157
6158 for ( size_t n = 0; n < WXSIZEOF(stringMatchTestData); n++ )
6159 {
6160 const StringMatchTestData& data = stringMatchTestData[n];
6161 bool matches = wxString(data.text).Matches(data.wildcard);
6162 wxPrintf(_T("'%s' %s '%s' (%s)\n"),
6163 data.wildcard,
6164 matches ? _T("matches") : _T("doesn't match"),
6165 data.text,
6166 matches == data.matches ? _T("ok") : _T("ERROR"));
6167 }
6168
6169 wxPuts(_T(""));
6170 }
6171
6172 #endif // TEST_STRINGS
6173
6174 // ----------------------------------------------------------------------------
6175 // entry point
6176 // ----------------------------------------------------------------------------
6177
6178 #ifdef TEST_SNGLINST
6179 #include "wx/snglinst.h"
6180 #endif // TEST_SNGLINST
6181
6182 int main(int argc, char **argv)
6183 {
6184 wxApp::CheckBuildOptions(wxBuildOptions());
6185
6186 wxInitializer initializer;
6187 if ( !initializer )
6188 {
6189 fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
6190
6191 return -1;
6192 }
6193
6194 #ifdef TEST_SNGLINST
6195 wxSingleInstanceChecker checker;
6196 if ( checker.Create(_T(".wxconsole.lock")) )
6197 {
6198 if ( checker.IsAnotherRunning() )
6199 {
6200 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
6201
6202 return 1;
6203 }
6204
6205 // wait some time to give time to launch another instance
6206 wxPrintf(_T("Press \"Enter\" to continue..."));
6207 wxFgetc(stdin);
6208 }
6209 else // failed to create
6210 {
6211 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
6212 }
6213 #endif // TEST_SNGLINST
6214
6215 #ifdef TEST_CHARSET
6216 TestCharset();
6217 #endif // TEST_CHARSET
6218
6219 #ifdef TEST_CMDLINE
6220 TestCmdLineConvert();
6221
6222 #if wxUSE_CMDLINE_PARSER
6223 static const wxCmdLineEntryDesc cmdLineDesc[] =
6224 {
6225 { wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
6226 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
6227 { wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
6228 { wxCMD_LINE_SWITCH, _T("q"), _T("quiet"), _T("be quiet") },
6229
6230 { wxCMD_LINE_OPTION, _T("o"), _T("output"), _T("output file") },
6231 { wxCMD_LINE_OPTION, _T("i"), _T("input"), _T("input dir") },
6232 { wxCMD_LINE_OPTION, _T("s"), _T("size"), _T("output block size"),
6233 wxCMD_LINE_VAL_NUMBER },
6234 { wxCMD_LINE_OPTION, _T("d"), _T("date"), _T("output file date"),
6235 wxCMD_LINE_VAL_DATE },
6236
6237 { wxCMD_LINE_PARAM, NULL, NULL, _T("input file"),
6238 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
6239
6240 { wxCMD_LINE_NONE }
6241 };
6242
6243 #if wxUSE_UNICODE
6244 wxChar **wargv = new wxChar *[argc + 1];
6245
6246 {
6247 for ( int n = 0; n < argc; n++ )
6248 {
6249 wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
6250 wargv[n] = wxStrdup(warg);
6251 }
6252
6253 wargv[n] = NULL;
6254 }
6255
6256 #define argv wargv
6257 #endif // wxUSE_UNICODE
6258
6259 wxCmdLineParser parser(cmdLineDesc, argc, argv);
6260
6261 #if wxUSE_UNICODE
6262 {
6263 for ( int n = 0; n < argc; n++ )
6264 free(wargv[n]);
6265
6266 delete [] wargv;
6267 }
6268 #endif // wxUSE_UNICODE
6269
6270 parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
6271 wxCMD_LINE_VAL_STRING,
6272 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
6273
6274 switch ( parser.Parse() )
6275 {
6276 case -1:
6277 wxLogMessage(_T("Help was given, terminating."));
6278 break;
6279
6280 case 0:
6281 ShowCmdLine(parser);
6282 break;
6283
6284 default:
6285 wxLogMessage(_T("Syntax error detected, aborting."));
6286 break;
6287 }
6288 #endif // wxUSE_CMDLINE_PARSER
6289
6290 #endif // TEST_CMDLINE
6291
6292 #ifdef TEST_STRINGS
6293 if ( TEST_ALL )
6294 {
6295 TestPChar();
6296 TestString();
6297 TestStringSub();
6298 TestStringConstruction();
6299 TestStringFormat();
6300 TestStringFind();
6301 TestStringTokenizer();
6302 TestStringReplace();
6303 }
6304 else
6305 {
6306 TestStringMatch();
6307 }
6308 #endif // TEST_STRINGS
6309
6310 #ifdef TEST_ARRAYS
6311 if ( TEST_ALL )
6312 {
6313 wxArrayString a1;
6314 a1.Add(_T("tiger"));
6315 a1.Add(_T("cat"));
6316 a1.Add(_T("lion"), 3);
6317 a1.Add(_T("dog"));
6318 a1.Add(_T("human"));
6319 a1.Add(_T("ape"));
6320
6321 wxPuts(_T("*** Initially:"));
6322
6323 PrintArray(_T("a1"), a1);
6324
6325 wxArrayString a2(a1);
6326 PrintArray(_T("a2"), a2);
6327
6328 wxSortedArrayString a3(a1);
6329 PrintArray(_T("a3"), a3);
6330
6331 wxPuts(_T("*** After deleting three strings from a1"));
6332 a1.Remove(2,3);
6333
6334 PrintArray(_T("a1"), a1);
6335 PrintArray(_T("a2"), a2);
6336 PrintArray(_T("a3"), a3);
6337
6338 wxPuts(_T("*** After reassigning a1 to a2 and a3"));
6339 a3 = a2 = a1;
6340 PrintArray(_T("a2"), a2);
6341 PrintArray(_T("a3"), a3);
6342
6343 wxPuts(_T("*** After sorting a1"));
6344 a1.Sort();
6345 PrintArray(_T("a1"), a1);
6346
6347 wxPuts(_T("*** After sorting a1 in reverse order"));
6348 a1.Sort(true);
6349 PrintArray(_T("a1"), a1);
6350
6351 wxPuts(_T("*** After sorting a1 by the string length"));
6352 a1.Sort(StringLenCompare);
6353 PrintArray(_T("a1"), a1);
6354
6355 TestArrayOfObjects();
6356 TestArrayOfUShorts();
6357 }
6358
6359 TestArrayOfInts();
6360 #endif // TEST_ARRAYS
6361
6362 #ifdef TEST_DIR
6363 if ( TEST_ALL )
6364 {
6365 TestDirExists();
6366 TestDirEnum();
6367 }
6368 TestDirTraverse();
6369 #endif // TEST_DIR
6370
6371 #ifdef TEST_DLLLOADER
6372 TestDllLoad();
6373 #endif // TEST_DLLLOADER
6374
6375 #ifdef TEST_ENVIRON
6376 TestEnvironment();
6377 #endif // TEST_ENVIRON
6378
6379 #ifdef TEST_EXECUTE
6380 TestExecute();
6381 #endif // TEST_EXECUTE
6382
6383 #ifdef TEST_FILECONF
6384 TestFileConfRead();
6385 #endif // TEST_FILECONF
6386
6387 #ifdef TEST_LIST
6388 TestListCtor();
6389 #endif // TEST_LIST
6390
6391 #ifdef TEST_LOCALE
6392 TestDefaultLang();
6393 #endif // TEST_LOCALE
6394
6395 #ifdef TEST_LOG
6396 wxPuts(_T("*** Testing wxLog ***"));
6397
6398 wxString s;
6399 for ( size_t n = 0; n < 8000; n++ )
6400 {
6401 s << (wxChar)(_T('A') + (n % 26));
6402 }
6403
6404 wxLogWarning(_T("The length of the string is %lu"),
6405 (unsigned long)s.length());
6406
6407 wxString msg;
6408 msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
6409
6410 // this one shouldn't be truncated
6411 wxPrintf(msg);
6412
6413 // but this one will because log functions use fixed size buffer
6414 // (note that it doesn't need '\n' at the end neither - will be added
6415 // by wxLog anyhow)
6416 wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
6417 #endif // TEST_LOG
6418
6419 #ifdef TEST_FILE
6420 if ( TEST_ALL )
6421 {
6422 TestFileRead();
6423 TestTextFileRead();
6424 TestFileCopy();
6425 }
6426 #endif // TEST_FILE
6427
6428 #ifdef TEST_FILENAME
6429 if ( 0 )
6430 {
6431 wxFileName fn;
6432 fn.Assign(_T("c:\\foo"), _T("bar.baz"));
6433 fn.Assign(_T("/u/os9-port/Viewer/tvision/WEI2HZ-3B3-14_05-04-00MSC1.asc"));
6434
6435 DumpFileName(fn);
6436 }
6437
6438 TestFileNameConstruction();
6439 if ( TEST_ALL )
6440 {
6441 TestFileNameConstruction();
6442 TestFileNameMakeRelative();
6443 TestFileNameMakeAbsolute();
6444 TestFileNameSplit();
6445 TestFileNameTemp();
6446 TestFileNameCwd();
6447 TestFileNameComparison();
6448 TestFileNameOperations();
6449 }
6450 #endif // TEST_FILENAME
6451
6452 #ifdef TEST_FILETIME
6453 TestFileGetTimes();
6454 if ( 0 )
6455 TestFileSetTimes();
6456 #endif // TEST_FILETIME
6457
6458 #ifdef TEST_FTP
6459 wxLog::AddTraceMask(FTP_TRACE_MASK);
6460 if ( TestFtpConnect() )
6461 {
6462 if ( TEST_ALL )
6463 {
6464 TestFtpList();
6465 TestFtpDownload();
6466 TestFtpMisc();
6467 TestFtpFileSize();
6468 TestFtpUpload();
6469 }
6470
6471 if ( TEST_INTERACTIVE )
6472 TestFtpInteractive();
6473 }
6474 //else: connecting to the FTP server failed
6475
6476 if ( 0 )
6477 TestFtpWuFtpd();
6478 #endif // TEST_FTP
6479
6480 #ifdef TEST_LONGLONG
6481 // seed pseudo random generator
6482 srand((unsigned)time(NULL));
6483
6484 if ( 0 )
6485 {
6486 TestSpeed();
6487 }
6488
6489 if ( TEST_ALL )
6490 {
6491 TestMultiplication();
6492 TestDivision();
6493 TestAddition();
6494 TestLongLongConversion();
6495 TestBitOperations();
6496 TestLongLongComparison();
6497 TestLongLongToString();
6498 TestLongLongPrintf();
6499 }
6500 #endif // TEST_LONGLONG
6501
6502 #ifdef TEST_HASH
6503 TestHash();
6504 #endif // TEST_HASH
6505
6506 #ifdef TEST_HASHMAP
6507 TestHashMap();
6508 #endif // TEST_HASHMAP
6509
6510 #ifdef TEST_MIME
6511 wxLog::AddTraceMask(_T("mime"));
6512 if ( TEST_ALL )
6513 {
6514 TestMimeEnum();
6515 TestMimeOverride();
6516 TestMimeAssociate();
6517 }
6518 TestMimeFilename();
6519 #endif // TEST_MIME
6520
6521 #ifdef TEST_INFO_FUNCTIONS
6522 if ( TEST_ALL )
6523 {
6524 TestOsInfo();
6525 TestUserInfo();
6526
6527 if ( TEST_INTERACTIVE )
6528 TestDiskInfo();
6529 }
6530 #endif // TEST_INFO_FUNCTIONS
6531
6532 #ifdef TEST_PATHLIST
6533 TestPathList();
6534 #endif // TEST_PATHLIST
6535
6536 #ifdef TEST_ODBC
6537 TestDbOpen();
6538 #endif // TEST_ODBC
6539
6540 #ifdef TEST_PRINTF
6541 TestPrintf();
6542 #endif // TEST_PRINTF
6543
6544 #ifdef TEST_REGCONF
6545 TestRegConfWrite();
6546 #endif // TEST_REGCONF
6547
6548 #ifdef TEST_REGEX
6549 // TODO: write a real test using src/regex/tests file
6550 if ( TEST_ALL )
6551 {
6552 TestRegExCompile();
6553 TestRegExMatch();
6554 TestRegExSubmatch();
6555 TestRegExReplacement();
6556
6557 if ( TEST_INTERACTIVE )
6558 TestRegExInteractive();
6559 }
6560 #endif // TEST_REGEX
6561
6562 #ifdef TEST_REGISTRY
6563 TestRegistryRead();
6564 TestRegistryAssociation();
6565 #endif // TEST_REGISTRY
6566
6567 #ifdef TEST_SOCKETS
6568 TestSocketServer();
6569 TestSocketClient();
6570 #endif // TEST_SOCKETS
6571
6572 #ifdef TEST_STREAMS
6573 if ( TEST_ALL )
6574 {
6575 TestFileStream();
6576 }
6577 TestMemoryStream();
6578 #endif // TEST_STREAMS
6579
6580 #ifdef TEST_TEXTSTREAM
6581 TestTextInputStream();
6582 #endif // TEST_TEXTSTREAM
6583
6584 #ifdef TEST_THREADS
6585 int nCPUs = wxThread::GetCPUCount();
6586 wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
6587 if ( nCPUs != -1 )
6588 wxThread::SetConcurrency(nCPUs);
6589
6590 TestDetachedThreads();
6591 if ( TEST_ALL )
6592 {
6593 TestJoinableThreads();
6594 TestThreadSuspend();
6595 TestThreadDelete();
6596 TestThreadConditions();
6597 TestThreadExec();
6598 TestSemaphore();
6599 }
6600 #endif // TEST_THREADS
6601
6602 #ifdef TEST_TIMER
6603 TestStopWatch();
6604 #endif // TEST_TIMER
6605
6606 #ifdef TEST_DATETIME
6607 if ( TEST_ALL )
6608 {
6609 TestTimeSet();
6610 TestTimeStatic();
6611 TestTimeRange();
6612 TestTimeZones();
6613 TestTimeTicks();
6614 TestTimeJDN();
6615 TestTimeDST();
6616 TestTimeWDays();
6617 TestTimeWNumber();
6618 TestTimeParse();
6619 TestTimeArithmetics();
6620 TestTimeHolidays();
6621 TestTimeFormat();
6622 TestTimeSpanFormat();
6623 TestTimeMS();
6624
6625 TestTimeZoneBug();
6626 }
6627
6628 TestTimeWNumber();
6629
6630 if ( TEST_INTERACTIVE )
6631 TestDateTimeInteractive();
6632 #endif // TEST_DATETIME
6633
6634 #ifdef TEST_USLEEP
6635 wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
6636 wxUsleep(3000);
6637 #endif // TEST_USLEEP
6638
6639 #ifdef TEST_VCARD
6640 TestVCardRead();
6641 TestVCardWrite();
6642 #endif // TEST_VCARD
6643
6644 #ifdef TEST_VOLUME
6645 TestFSVolume();
6646 #endif // TEST_VOLUME
6647
6648 #ifdef TEST_UNICODE
6649 TestUnicodeToFromAscii();
6650 #endif // TEST_UNICODE
6651
6652 #ifdef TEST_WCHAR
6653 TestUtf8();
6654 TestEncodingConverter();
6655 #endif // TEST_WCHAR
6656
6657 #ifdef TEST_ZIP
6658 TestZipStreamRead();
6659 TestZipFileSystem();
6660 #endif // TEST_ZIP
6661
6662 #ifdef TEST_ZLIB
6663 TestZlibStreamWrite();
6664 TestZlibStreamRead();
6665 #endif // TEST_ZLIB
6666
6667 return 0;
6668 }
6669
wxWidgets (Impactor)