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