projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
compilation fix in !WXWIN_COMPATIBILITY_2_2 mode; set TEST_ALL to 1
[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_THREADS
85 #define TEST_TIMER
86 #define TEST_UNICODE
87 // #define TEST_VCARD -- don't enable this (VZ)
88 #define TEST_VOLUME
89 #define TEST_WCHAR
90 #define TEST_ZIP
91 #define TEST_ZLIB
92
93 #undef TEST_ALL
94 static const bool TEST_ALL = TRUE;
95 #else
96 #define TEST_PRINTF
97
98 static const bool TEST_ALL = FALSE;
99 #endif
100
101 // some tests are interactive, define this to run them
102 #ifdef TEST_INTERACTIVE
103 #undef TEST_INTERACTIVE
104
105 static const bool TEST_INTERACTIVE = TRUE;
106 #else
107 static const bool TEST_INTERACTIVE = FALSE;
108 #endif
109
110 // ----------------------------------------------------------------------------
111 // test class for container objects
112 // ----------------------------------------------------------------------------
113
114 #if defined(TEST_ARRAYS) || defined(TEST_LIST)
115
116 class Bar // Foo is already taken in the hash test
117 {
118 public:
119 Bar(const wxString& name) : m_name(name) { ms_bars++; }
120 Bar(const Bar& bar) : m_name(bar.m_name) { ms_bars++; }
121 ~Bar() { ms_bars--; }
122
123 static size_t GetNumber() { return ms_bars; }
124
125 const wxChar *GetName() const { return m_name; }
126
127 private:
128 wxString m_name;
129
130 static size_t ms_bars;
131 };
132
133 size_t Bar::ms_bars = 0;
134
135 #endif // defined(TEST_ARRAYS) || defined(TEST_LIST)
136
137 // ============================================================================
138 // implementation
139 // ============================================================================
140
141 // ----------------------------------------------------------------------------
142 // helper functions
143 // ----------------------------------------------------------------------------
144
145 #if defined(TEST_STRINGS) || defined(TEST_SOCKETS)
146
147 // replace TABs with \t and CRs with \n
148 static wxString MakePrintable(const wxChar *s)
149 {
150 wxString str(s);
151 (void)str.Replace(_T("\t"), _T("\\t"));
152 (void)str.Replace(_T("\n"), _T("\\n"));
153 (void)str.Replace(_T("\r"), _T("\\r"));
154
155 return str;
156 }
157
158 #endif // MakePrintable() is used
159
160 // ----------------------------------------------------------------------------
161 // wxFontMapper::CharsetToEncoding
162 // ----------------------------------------------------------------------------
163
164 #ifdef TEST_CHARSET
165
166 #include "wx/fontmap.h"
167
168 static void TestCharset()
169 {
170 static const wxChar *charsets[] =
171 {
172 // some vali charsets
173 _T("us-ascii "),
174 _T("iso8859-1 "),
175 _T("iso-8859-12 "),
176 _T("koi8-r "),
177 _T("utf-7 "),
178 _T("cp1250 "),
179 _T("windows-1252"),
180
181 // and now some bogus ones
182 _T(" "),
183 _T("cp1249 "),
184 _T("iso--8859-1 "),
185 _T("iso-8859-19 "),
186 };
187
188 for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
189 {
190 wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charsets[n]);
191 wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
192 charsets[n],
193 wxFontMapper::Get()->GetEncodingName(enc).c_str(),
194 wxFontMapper::Get()->GetEncodingDescription(enc).c_str());
195 }
196 }
197
198 #endif // TEST_CHARSET
199
200 // ----------------------------------------------------------------------------
201 // wxCmdLineParser
202 // ----------------------------------------------------------------------------
203
204 #ifdef TEST_CMDLINE
205
206 #include "wx/cmdline.h"
207 #include "wx/datetime.h"
208 #include "wx/log.h"
209
210 #if wxUSE_CMDLINE_PARSER
211
212 static void ShowCmdLine(const wxCmdLineParser& parser)
213 {
214 wxString s = _T("Input files: ");
215
216 size_t count = parser.GetParamCount();
217 for ( size_t param = 0; param < count; param++ )
218 {
219 s << parser.GetParam(param) << ' ';
220 }
221
222 s << '\n'
223 << _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
224 << _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
225
226 wxString strVal;
227 long lVal;
228 wxDateTime dt;
229 if ( parser.Found(_T("o"), &strVal) )
230 s << _T("Output file:\t") << strVal << '\n';
231 if ( parser.Found(_T("i"), &strVal) )
232 s << _T("Input dir:\t") << strVal << '\n';
233 if ( parser.Found(_T("s"), &lVal) )
234 s << _T("Size:\t") << lVal << '\n';
235 if ( parser.Found(_T("d"), &dt) )
236 s << _T("Date:\t") << dt.FormatISODate() << '\n';
237 if ( parser.Found(_T("project_name"), &strVal) )
238 s << _T("Project:\t") << strVal << '\n';
239
240 wxLogMessage(s);
241 }
242
243 #endif // wxUSE_CMDLINE_PARSER
244
245 static void TestCmdLineConvert()
246 {
247 static const wxChar *cmdlines[] =
248 {
249 _T("arg1 arg2"),
250 _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
251 _T("literal \\\" and \"\""),
252 };
253
254 for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
255 {
256 const wxChar *cmdline = cmdlines[n];
257 wxPrintf(_T("Parsing: %s\n"), cmdline);
258 wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
259
260 size_t count = args.GetCount();
261 wxPrintf(_T("\targc = %u\n"), count);
262 for ( size_t arg = 0; arg < count; arg++ )
263 {
264 wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
265 }
266 }
267 }
268
269 #endif // TEST_CMDLINE
270
271 // ----------------------------------------------------------------------------
272 // wxDir
273 // ----------------------------------------------------------------------------
274
275 #ifdef TEST_DIR
276
277 #include "wx/dir.h"
278
279 #ifdef __UNIX__
280 static const wxChar *ROOTDIR = _T("/");
281 static const wxChar *TESTDIR = _T("/usr");
282 #elif defined(__WXMSW__)
283 static const wxChar *ROOTDIR = _T("c:\\");
284 static const wxChar *TESTDIR = _T("d:\\");
285 #else
286 #error "don't know where the root directory is"
287 #endif
288
289 static void TestDirEnumHelper(wxDir& dir,
290 int flags = wxDIR_DEFAULT,
291 const wxString& filespec = wxEmptyString)
292 {
293 wxString filename;
294
295 if ( !dir.IsOpened() )
296 return;
297
298 bool cont = dir.GetFirst(&filename, filespec, flags);
299 while ( cont )
300 {
301 wxPrintf(_T("\t%s\n"), filename.c_str());
302
303 cont = dir.GetNext(&filename);
304 }
305
306 wxPuts(_T(""));
307 }
308
309 static void TestDirEnum()
310 {
311 wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
312
313 wxString cwd = wxGetCwd();
314 if ( !wxDir::Exists(cwd) )
315 {
316 wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
317 return;
318 }
319
320 wxDir dir(cwd);
321 if ( !dir.IsOpened() )
322 {
323 wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
324 return;
325 }
326
327 wxPuts(_T("Enumerating everything in current directory:"));
328 TestDirEnumHelper(dir);
329
330 wxPuts(_T("Enumerating really everything in current directory:"));
331 TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
332
333 wxPuts(_T("Enumerating object files in current directory:"));
334 TestDirEnumHelper(dir, wxDIR_DEFAULT, "*.o*");
335
336 wxPuts(_T("Enumerating directories in current directory:"));
337 TestDirEnumHelper(dir, wxDIR_DIRS);
338
339 wxPuts(_T("Enumerating files in current directory:"));
340 TestDirEnumHelper(dir, wxDIR_FILES);
341
342 wxPuts(_T("Enumerating files including hidden in current directory:"));
343 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
344
345 dir.Open(ROOTDIR);
346
347 wxPuts(_T("Enumerating everything in root directory:"));
348 TestDirEnumHelper(dir, wxDIR_DEFAULT);
349
350 wxPuts(_T("Enumerating directories in root directory:"));
351 TestDirEnumHelper(dir, wxDIR_DIRS);
352
353 wxPuts(_T("Enumerating files in root directory:"));
354 TestDirEnumHelper(dir, wxDIR_FILES);
355
356 wxPuts(_T("Enumerating files including hidden in root directory:"));
357 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
358
359 wxPuts(_T("Enumerating files in non existing directory:"));
360 wxDir dirNo("nosuchdir");
361 TestDirEnumHelper(dirNo);
362 }
363
364 class DirPrintTraverser : public wxDirTraverser
365 {
366 public:
367 virtual wxDirTraverseResult OnFile(const wxString& filename)
368 {
369 return wxDIR_CONTINUE;
370 }
371
372 virtual wxDirTraverseResult OnDir(const wxString& dirname)
373 {
374 wxString path, name, ext;
375 wxSplitPath(dirname, &path, &name, &ext);
376
377 if ( !ext.empty() )
378 name << _T('.') << ext;
379
380 wxString indent;
381 for ( const wxChar *p = path.c_str(); *p; p++ )
382 {
383 if ( wxIsPathSeparator(*p) )
384 indent += _T(" ");
385 }
386
387 wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
388
389 return wxDIR_CONTINUE;
390 }
391 };
392
393 static void TestDirTraverse()
394 {
395 wxPuts(_T("*** Testing wxDir::Traverse() ***"));
396
397 // enum all files
398 wxArrayString files;
399 size_t n = wxDir::GetAllFiles(TESTDIR, &files);
400 wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
401 if ( n > 1 )
402 {
403 wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
404 wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
405 }
406
407 // enum again with custom traverser
408 wxDir dir(TESTDIR);
409 DirPrintTraverser traverser;
410 dir.Traverse(traverser, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
411 }
412
413 static void TestDirExists()
414 {
415 wxPuts(_T("*** Testing wxDir::Exists() ***"));
416
417 static const wxChar *dirnames[] =
418 {
419 _T("."),
420 #if defined(__WXMSW__)
421 _T("c:"),
422 _T("c:\\"),
423 _T("\\\\share\\file"),
424 _T("c:\\dos"),
425 _T("c:\\dos\\"),
426 _T("c:\\dos\\\\"),
427 _T("c:\\autoexec.bat"),
428 #elif defined(__UNIX__)
429 _T("/"),
430 _T("//"),
431 _T("/usr/bin"),
432 _T("/usr//bin"),
433 _T("/usr///bin"),
434 #endif
435 };
436
437 for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
438 {
439 wxPrintf(_T("%-40s: %s\n"),
440 dirnames[n],
441 wxDir::Exists(dirnames[n]) ? _T("exists")
442 : _T("doesn't exist"));
443 }
444 }
445
446 #endif // TEST_DIR
447
448 // ----------------------------------------------------------------------------
449 // wxDllLoader
450 // ----------------------------------------------------------------------------
451
452 #ifdef TEST_DLLLOADER
453
454 #include "wx/dynlib.h"
455
456 static void TestDllLoad()
457 {
458 #if defined(__WXMSW__)
459 static const wxChar *LIB_NAME = _T("kernel32.dll");
460 static const wxChar *FUNC_NAME = _T("lstrlenA");
461 #elif defined(__UNIX__)
462 // weird: using just libc.so does *not* work!
463 static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
464 static const wxChar *FUNC_NAME = _T("strlen");
465 #else
466 #error "don't know how to test wxDllLoader on this platform"
467 #endif
468
469 wxPuts(_T("*** testing wxDllLoader ***\n"));
470
471 wxDynamicLibrary lib(LIB_NAME);
472 if ( !lib.IsLoaded() )
473 {
474 wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
475 }
476 else
477 {
478 typedef int (*wxStrlenType)(const char *);
479 wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
480 if ( !pfnStrlen )
481 {
482 wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
483 FUNC_NAME, LIB_NAME);
484 }
485 else
486 {
487 if ( pfnStrlen("foo") != 3 )
488 {
489 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
490 }
491 else
492 {
493 wxPuts(_T("... ok"));
494 }
495 }
496 }
497 }
498
499 #endif // TEST_DLLLOADER
500
501 // ----------------------------------------------------------------------------
502 // wxGet/SetEnv
503 // ----------------------------------------------------------------------------
504
505 #ifdef TEST_ENVIRON
506
507 #include "wx/utils.h"
508
509 static wxString MyGetEnv(const wxString& var)
510 {
511 wxString val;
512 if ( !wxGetEnv(var, &val) )
513 val = _T("<empty>");
514 else
515 val = wxString(_T('\'')) + val + _T('\'');
516
517 return val;
518 }
519
520 static void TestEnvironment()
521 {
522 const wxChar *var = _T("wxTestVar");
523
524 wxPuts(_T("*** testing environment access functions ***"));
525
526 wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
527 wxSetEnv(var, _T("value for wxTestVar"));
528 wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
529 wxSetEnv(var, _T("another value"));
530 wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
531 wxUnsetEnv(var);
532 wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
533 wxPrintf(_T("PATH = %s\n"), MyGetEnv(_T("PATH")).c_str());
534 }
535
536 #endif // TEST_ENVIRON
537
538 // ----------------------------------------------------------------------------
539 // wxExecute
540 // ----------------------------------------------------------------------------
541
542 #ifdef TEST_EXECUTE
543
544 #include "wx/utils.h"
545
546 static void TestExecute()
547 {
548 wxPuts(_T("*** testing wxExecute ***"));
549
550 #ifdef __UNIX__
551 #define COMMAND "cat -n ../../Makefile" // "echo hi"
552 #define SHELL_COMMAND "echo hi from shell"
553 #define REDIRECT_COMMAND COMMAND // "date"
554 #elif defined(__WXMSW__)
555 #define COMMAND "command.com /c echo hi"
556 #define SHELL_COMMAND "echo hi"
557 #define REDIRECT_COMMAND COMMAND
558 #else
559 #error "no command to exec"
560 #endif // OS
561
562 wxPrintf(_T("Testing wxShell: "));
563 fflush(stdout);
564 if ( wxShell(SHELL_COMMAND) )
565 wxPuts(_T("Ok."));
566 else
567 wxPuts(_T("ERROR."));
568
569 wxPrintf(_T("Testing wxExecute: "));
570 fflush(stdout);
571 if ( wxExecute(COMMAND, TRUE /* sync */) == 0 )
572 wxPuts(_T("Ok."));
573 else
574 wxPuts(_T("ERROR."));
575
576 #if 0 // no, it doesn't work (yet?)
577 wxPrintf(_T("Testing async wxExecute: "));
578 fflush(stdout);
579 if ( wxExecute(COMMAND) != 0 )
580 wxPuts(_T("Ok (command launched)."));
581 else
582 wxPuts(_T("ERROR."));
583 #endif // 0
584
585 wxPrintf(_T("Testing wxExecute with redirection:\n"));
586 wxArrayString output;
587 if ( wxExecute(REDIRECT_COMMAND, output) != 0 )
588 {
589 wxPuts(_T("ERROR."));
590 }
591 else
592 {
593 size_t count = output.GetCount();
594 for ( size_t n = 0; n < count; n++ )
595 {
596 wxPrintf(_T("\t%s\n"), output[n].c_str());
597 }
598
599 wxPuts(_T("Ok."));
600 }
601 }
602
603 #endif // TEST_EXECUTE
604
605 // ----------------------------------------------------------------------------
606 // file
607 // ----------------------------------------------------------------------------
608
609 #ifdef TEST_FILE
610
611 #include "wx/file.h"
612 #include "wx/ffile.h"
613 #include "wx/textfile.h"
614
615 static void TestFileRead()
616 {
617 wxPuts(_T("*** wxFile read test ***"));
618
619 wxFile file(_T("testdata.fc"));
620 if ( file.IsOpened() )
621 {
622 wxPrintf(_T("File length: %lu\n"), file.Length());
623
624 wxPuts(_T("File dump:\n----------"));
625
626 static const off_t len = 1024;
627 wxChar buf[len];
628 for ( ;; )
629 {
630 off_t nRead = file.Read(buf, len);
631 if ( nRead == wxInvalidOffset )
632 {
633 wxPrintf(_T("Failed to read the file."));
634 break;
635 }
636
637 fwrite(buf, nRead, 1, stdout);
638
639 if ( nRead < len )
640 break;
641 }
642
643 wxPuts(_T("----------"));
644 }
645 else
646 {
647 wxPrintf(_T("ERROR: can't open test file.\n"));
648 }
649
650 wxPuts(_T(""));
651 }
652
653 static void TestTextFileRead()
654 {
655 wxPuts(_T("*** wxTextFile read test ***"));
656
657 wxTextFile file(_T("testdata.fc"));
658 if ( file.Open() )
659 {
660 wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
661 wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
662
663 wxString s;
664
665 wxPuts(_T("\nDumping the entire file:"));
666 for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
667 {
668 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
669 }
670 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
671
672 wxPuts(_T("\nAnd now backwards:"));
673 for ( s = file.GetLastLine();
674 file.GetCurrentLine() != 0;
675 s = file.GetPrevLine() )
676 {
677 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
678 }
679 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
680 }
681 else
682 {
683 wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
684 }
685
686 wxPuts(_T(""));
687 }
688
689 static void TestFileCopy()
690 {
691 wxPuts(_T("*** Testing wxCopyFile ***"));
692
693 static const wxChar *filename1 = _T("testdata.fc");
694 static const wxChar *filename2 = _T("test2");
695 if ( !wxCopyFile(filename1, filename2) )
696 {
697 wxPuts(_T("ERROR: failed to copy file"));
698 }
699 else
700 {
701 wxFFile f1(filename1, "rb"),
702 f2(filename2, "rb");
703
704 if ( !f1.IsOpened() || !f2.IsOpened() )
705 {
706 wxPuts(_T("ERROR: failed to open file(s)"));
707 }
708 else
709 {
710 wxString s1, s2;
711 if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
712 {
713 wxPuts(_T("ERROR: failed to read file(s)"));
714 }
715 else
716 {
717 if ( (s1.length() != s2.length()) ||
718 (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
719 {
720 wxPuts(_T("ERROR: copy error!"));
721 }
722 else
723 {
724 wxPuts(_T("File was copied ok."));
725 }
726 }
727 }
728 }
729
730 if ( !wxRemoveFile(filename2) )
731 {
732 wxPuts(_T("ERROR: failed to remove the file"));
733 }
734
735 wxPuts(_T(""));
736 }
737
738 #endif // TEST_FILE
739
740 // ----------------------------------------------------------------------------
741 // wxFileConfig
742 // ----------------------------------------------------------------------------
743
744 #ifdef TEST_FILECONF
745
746 #include "wx/confbase.h"
747 #include "wx/fileconf.h"
748
749 static const struct FileConfTestData
750 {
751 const wxChar *name; // value name
752 const wxChar *value; // the value from the file
753 } fcTestData[] =
754 {
755 { _T("value1"), _T("one") },
756 { _T("value2"), _T("two") },
757 { _T("novalue"), _T("default") },
758 };
759
760 static void TestFileConfRead()
761 {
762 wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
763
764 wxFileConfig fileconf(_T("test"), wxEmptyString,
765 _T("testdata.fc"), wxEmptyString,
766 wxCONFIG_USE_RELATIVE_PATH);
767
768 // test simple reading
769 wxPuts(_T("\nReading config file:"));
770 wxString defValue(_T("default")), value;
771 for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
772 {
773 const FileConfTestData& data = fcTestData[n];
774 value = fileconf.Read(data.name, defValue);
775 wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
776 if ( value == data.value )
777 {
778 wxPuts(_T("(ok)"));
779 }
780 else
781 {
782 wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
783 }
784 }
785
786 // test enumerating the entries
787 wxPuts(_T("\nEnumerating all root entries:"));
788 long dummy;
789 wxString name;
790 bool cont = fileconf.GetFirstEntry(name, dummy);
791 while ( cont )
792 {
793 wxPrintf(_T("\t%s = %s\n"),
794 name.c_str(),
795 fileconf.Read(name.c_str(), _T("ERROR")).c_str());
796
797 cont = fileconf.GetNextEntry(name, dummy);
798 }
799 }
800
801 #endif // TEST_FILECONF
802
803 // ----------------------------------------------------------------------------
804 // wxFileName
805 // ----------------------------------------------------------------------------
806
807 #ifdef TEST_FILENAME
808
809 #include "wx/filename.h"
810
811 static void DumpFileName(const wxFileName& fn)
812 {
813 wxString full = fn.GetFullPath();
814
815 wxString vol, path, name, ext;
816 wxFileName::SplitPath(full, &vol, &path, &name, &ext);
817
818 wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
819 full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
820
821 wxFileName::SplitPath(full, &path, &name, &ext);
822 wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
823 path.c_str(), name.c_str(), ext.c_str());
824
825 wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
826 wxPrintf(_T("with volume: \t'%s'\n"),
827 fn.GetPath(wxPATH_GET_VOLUME).c_str());
828 wxPrintf(_T("with separator:\t'%s'\n"),
829 fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
830 wxPrintf(_T("with both: \t'%s'\n"),
831 fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
832
833 wxPuts(_T("The directories in the path are:"));
834 wxArrayString dirs = fn.GetDirs();
835 size_t count = dirs.GetCount();
836 for ( size_t n = 0; n < count; n++ )
837 {
838 wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
839 }
840 }
841
842 static struct FileNameInfo
843 {
844 const wxChar *fullname;
845 const wxChar *volume;
846 const wxChar *path;
847 const wxChar *name;
848 const wxChar *ext;
849 bool isAbsolute;
850 wxPathFormat format;
851 } filenames[] =
852 {
853 // Unix file names
854 { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), TRUE, wxPATH_UNIX },
855 { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), TRUE, wxPATH_UNIX },
856 { _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), TRUE, wxPATH_UNIX },
857 { _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), FALSE, wxPATH_UNIX },
858 { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
859 { _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), TRUE, wxPATH_UNIX },
860 { _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), TRUE, wxPATH_UNIX },
861 { _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
862 { _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), TRUE, wxPATH_UNIX },
863
864 // Windows file names
865 { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
866 { _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
867 { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
868 { _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
869 { _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), TRUE, wxPATH_DOS },
870 { _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
871 { _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
872
873 // wxFileName support for Mac file names is broken currently
874 #if 0
875 // Mac file names
876 { _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
877 { _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
878 { _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), TRUE, wxPATH_MAC },
879 { _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), FALSE, wxPATH_MAC },
880 { _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
881 { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
882 #endif // 0
883
884 // VMS file names
885 { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE, wxPATH_VMS },
886 { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), FALSE, wxPATH_VMS },
887 };
888
889 static void TestFileNameConstruction()
890 {
891 wxPuts(_T("*** testing wxFileName construction ***"));
892
893 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
894 {
895 const FileNameInfo& fni = filenames[n];
896
897 wxFileName fn(fni.fullname, fni.format);
898
899 wxString fullname = fn.GetFullPath(fni.format);
900 if ( fullname != fni.fullname )
901 {
902 wxPrintf(_T("ERROR: fullname should be '%s'\n"), fni.fullname);
903 }
904
905 bool isAbsolute = fn.IsAbsolute(fni.format);
906 wxPrintf(_T("'%s' is %s (%s)\n\t"),
907 fullname.c_str(),
908 isAbsolute ? "absolute" : "relative",
909 isAbsolute == fni.isAbsolute ? "ok" : "ERROR");
910
911 if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), fni.format) )
912 {
913 wxPuts(_T("ERROR (couldn't be normalized)"));
914 }
915 else
916 {
917 wxPrintf(_T("normalized: '%s'\n"), fn.GetFullPath(fni.format).c_str());
918 }
919 }
920
921 wxPuts(_T(""));
922 }
923
924 static void TestFileNameSplit()
925 {
926 wxPuts(_T("*** testing wxFileName splitting ***"));
927
928 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
929 {
930 const FileNameInfo& fni = filenames[n];
931 wxString volume, path, name, ext;
932 wxFileName::SplitPath(fni.fullname,
933 &volume, &path, &name, &ext, fni.format);
934
935 wxPrintf(_T("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'"),
936 fni.fullname,
937 volume.c_str(), path.c_str(), name.c_str(), ext.c_str());
938
939 if ( volume != fni.volume )
940 wxPrintf(_T(" (ERROR: volume = '%s')"), fni.volume);
941 if ( path != fni.path )
942 wxPrintf(_T(" (ERROR: path = '%s')"), fni.path);
943 if ( name != fni.name )
944 wxPrintf(_T(" (ERROR: name = '%s')"), fni.name);
945 if ( ext != fni.ext )
946 wxPrintf(_T(" (ERROR: ext = '%s')"), fni.ext);
947
948 wxPuts(_T(""));
949 }
950 }
951
952 static void TestFileNameTemp()
953 {
954 wxPuts(_T("*** testing wxFileName temp file creation ***"));
955
956 static const wxChar *tmpprefixes[] =
957 {
958 _T(""),
959 _T("foo"),
960 _T(".."),
961 _T("../bar"),
962 #ifdef __UNIX__
963 _T("/tmp/foo"),
964 _T("/tmp/foo/bar"), // this one must be an error
965 #endif // __UNIX__
966 };
967
968 for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
969 {
970 wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
971 if ( path.empty() )
972 {
973 // "error" is not in upper case because it may be ok
974 wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
975 }
976 else
977 {
978 wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
979 tmpprefixes[n], path.c_str());
980
981 if ( !wxRemoveFile(path) )
982 {
983 wxLogWarning(_T("Failed to remove temp file '%s'"),
984 path.c_str());
985 }
986 }
987 }
988 }
989
990 static void TestFileNameMakeRelative()
991 {
992 wxPuts(_T("*** testing wxFileName::MakeRelativeTo() ***"));
993
994 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
995 {
996 const FileNameInfo& fni = filenames[n];
997
998 wxFileName fn(fni.fullname, fni.format);
999
1000 // choose the base dir of the same format
1001 wxString base;
1002 switch ( fni.format )
1003 {
1004 case wxPATH_UNIX:
1005 base = "/usr/bin/";
1006 break;
1007
1008 case wxPATH_DOS:
1009 base = "c:\\";
1010 break;
1011
1012 case wxPATH_MAC:
1013 case wxPATH_VMS:
1014 // TODO: I don't know how this is supposed to work there
1015 continue;
1016
1017 case wxPATH_NATIVE: // make gcc happy
1018 default:
1019 wxFAIL_MSG( "unexpected path format" );
1020 }
1021
1022 wxPrintf(_T("'%s' relative to '%s': "),
1023 fn.GetFullPath(fni.format).c_str(), base.c_str());
1024
1025 if ( !fn.MakeRelativeTo(base, fni.format) )
1026 {
1027 wxPuts(_T("unchanged"));
1028 }
1029 else
1030 {
1031 wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
1032 }
1033 }
1034 }
1035
1036 static void TestFileNameComparison()
1037 {
1038 // TODO!
1039 }
1040
1041 static void TestFileNameOperations()
1042 {
1043 // TODO!
1044 }
1045
1046 static void TestFileNameCwd()
1047 {
1048 // TODO!
1049 }
1050
1051 #endif // TEST_FILENAME
1052
1053 // ----------------------------------------------------------------------------
1054 // wxFileName time functions
1055 // ----------------------------------------------------------------------------
1056
1057 #ifdef TEST_FILETIME
1058
1059 #include <wx/filename.h>
1060 #include <wx/datetime.h>
1061
1062 static void TestFileGetTimes()
1063 {
1064 wxFileName fn(_T("testdata.fc"));
1065
1066 wxDateTime dtAccess, dtMod, dtCreate;
1067 if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
1068 {
1069 wxPrintf(_T("ERROR: GetTimes() failed.\n"));
1070 }
1071 else
1072 {
1073 static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
1074
1075 wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
1076 wxPrintf(_T("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
1077 wxPrintf(_T("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
1078 wxPrintf(_T("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
1079 }
1080 }
1081
1082 static void TestFileSetTimes()
1083 {
1084 wxFileName fn(_T("testdata.fc"));
1085
1086 if ( !fn.Touch() )
1087 {
1088 wxPrintf(_T("ERROR: Touch() failed.\n"));
1089 }
1090 }
1091
1092 #endif // TEST_FILETIME
1093
1094 // ----------------------------------------------------------------------------
1095 // wxHashTable
1096 // ----------------------------------------------------------------------------
1097
1098 #ifdef TEST_HASH
1099
1100 #include "wx/hash.h"
1101
1102 struct Foo
1103 {
1104 Foo(int n_) { n = n_; count++; }
1105 ~Foo() { count--; }
1106
1107 int n;
1108
1109 static size_t count;
1110 };
1111
1112 size_t Foo::count = 0;
1113
1114 WX_DECLARE_LIST(Foo, wxListFoos);
1115 WX_DECLARE_HASH(Foo, wxListFoos, wxHashFoos);
1116
1117 #include "wx/listimpl.cpp"
1118
1119 WX_DEFINE_LIST(wxListFoos);
1120
1121 static void TestHash()
1122 {
1123 wxPuts(_T("*** Testing wxHashTable ***\n"));
1124
1125 {
1126 wxHashFoos hash;
1127 hash.DeleteContents(TRUE);
1128
1129 wxPrintf(_T("Hash created: %u foos in hash, %u foos totally\n"),
1130 hash.GetCount(), Foo::count);
1131
1132 static const int hashTestData[] =
1133 {
1134 0, 1, 17, -2, 2, 4, -4, 345, 3, 3, 2, 1,
1135 };
1136
1137 size_t n;
1138 for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
1139 {
1140 hash.Put(hashTestData[n], n, new Foo(n));
1141 }
1142
1143 wxPrintf(_T("Hash filled: %u foos in hash, %u foos totally\n"),
1144 hash.GetCount(), Foo::count);
1145
1146 wxPuts(_T("Hash access test:"));
1147 for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
1148 {
1149 wxPrintf(_T("\tGetting element with key %d, value %d: "),
1150 hashTestData[n], n);
1151 Foo *foo = hash.Get(hashTestData[n], n);
1152 if ( !foo )
1153 {
1154 wxPrintf(_T("ERROR, not found.\n"));
1155 }
1156 else
1157 {
1158 wxPrintf(_T("%d (%s)\n"), foo->n,
1159 (size_t)foo->n == n ? "ok" : "ERROR");
1160 }
1161 }
1162
1163 wxPrintf(_T("\nTrying to get an element not in hash: "));
1164
1165 if ( hash.Get(1234) || hash.Get(1, 0) )
1166 {
1167 wxPuts(_T("ERROR: found!"));
1168 }
1169 else
1170 {
1171 wxPuts(_T("ok (not found)"));
1172 }
1173 }
1174
1175 wxPrintf(_T("Hash destroyed: %u foos left\n"), Foo::count);
1176 }
1177
1178 #endif // TEST_HASH
1179
1180 // ----------------------------------------------------------------------------
1181 // wxHashMap
1182 // ----------------------------------------------------------------------------
1183
1184 #ifdef TEST_HASHMAP
1185
1186 #include "wx/hashmap.h"
1187
1188 // test compilation of basic map types
1189 WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash, wxPointerEqual, myPtrHashMap );
1190 WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
1191 WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
1192 myUnsignedHashMap );
1193 WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
1194 myTestHashMap1 );
1195 WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
1196 myTestHashMap2 );
1197 WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
1198 myTestHashMap3 );
1199 WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
1200 myTestHashMap4 );
1201
1202 // same as:
1203 // WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
1204 // myStringHashMap );
1205 WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
1206
1207 typedef myStringHashMap::iterator Itor;
1208
1209 static void TestHashMap()
1210 {
1211 wxPuts(_T("*** Testing wxHashMap ***\n"));
1212 myStringHashMap sh(0); // as small as possible
1213 wxString buf;
1214 size_t i;
1215 const size_t count = 10000;
1216
1217 // init with some data
1218 for( i = 0; i < count; ++i )
1219 {
1220 buf.Printf(wxT("%d"), i );
1221 sh[buf] = wxT("A") + buf + wxT("C");
1222 }
1223
1224 // test that insertion worked
1225 if( sh.size() != count )
1226 {
1227 wxPrintf(_T("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n"), sh.size(), count);
1228 }
1229
1230 for( i = 0; i < count; ++i )
1231 {
1232 buf.Printf(wxT("%d"), i );
1233 if( sh[buf] != wxT("A") + buf + wxT("C") )
1234 {
1235 wxPrintf(_T("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n"));
1236 return;
1237 }
1238 }
1239
1240 // check that iterators work
1241 Itor it;
1242 for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1243 {
1244 if( i == count )
1245 {
1246 wxPrintf(_T("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n"));
1247 return;
1248 }
1249
1250 if( it->second != sh[it->first] )
1251 {
1252 wxPrintf(_T("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n"));
1253 return;
1254 }
1255 }
1256
1257 if( sh.size() != i )
1258 {
1259 wxPrintf(_T("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n"), i, count);
1260 }
1261
1262 // test copy ctor, assignment operator
1263 myStringHashMap h1( sh ), h2( 0 );
1264 h2 = sh;
1265
1266 for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1267 {
1268 if( h1[it->first] != it->second )
1269 {
1270 wxPrintf(_T("*** ERROR: COPY CTOR BROKEN %s ***\n"), it->first.c_str());
1271 }
1272
1273 if( h2[it->first] != it->second )
1274 {
1275 wxPrintf(_T("*** ERROR: OPERATOR= BROKEN %s ***\n"), it->first.c_str());
1276 }
1277 }
1278
1279 // other tests
1280 for( i = 0; i < count; ++i )
1281 {
1282 buf.Printf(wxT("%d"), i );
1283 size_t sz = sh.size();
1284
1285 // test find() and erase(it)
1286 if( i < 100 )
1287 {
1288 it = sh.find( buf );
1289 if( it != sh.end() )
1290 {
1291 sh.erase( it );
1292
1293 if( sh.find( buf ) != sh.end() )
1294 {
1295 wxPrintf(_T("*** ERROR: FOUND DELETED ELEMENT %u ***\n"), i);
1296 }
1297 }
1298 else
1299 wxPrintf(_T("*** ERROR: CANT FIND ELEMENT %u ***\n"), i);
1300 }
1301 else
1302 // test erase(key)
1303 {
1304 size_t c = sh.erase( buf );
1305 if( c != 1 )
1306 wxPrintf(_T("*** ERROR: SHOULD RETURN 1 ***\n"));
1307
1308 if( sh.find( buf ) != sh.end() )
1309 {
1310 wxPrintf(_T("*** ERROR: FOUND DELETED ELEMENT %u ***\n"), i);
1311 }
1312 }
1313
1314 // count should decrease
1315 if( sh.size() != sz - 1 )
1316 {
1317 wxPrintf(_T("*** ERROR: COUNT DID NOT DECREASE ***\n"));
1318 }
1319 }
1320
1321 wxPrintf(_T("*** Finished testing wxHashMap ***\n"));
1322 }
1323
1324 #endif // TEST_HASHMAP
1325
1326 // ----------------------------------------------------------------------------
1327 // wxList
1328 // ----------------------------------------------------------------------------
1329
1330 #ifdef TEST_LIST
1331
1332 #include "wx/list.h"
1333
1334 WX_DECLARE_LIST(Bar, wxListBars);
1335 #include "wx/listimpl.cpp"
1336 WX_DEFINE_LIST(wxListBars);
1337
1338 static void TestListCtor()
1339 {
1340 wxPuts(_T("*** Testing wxList construction ***\n"));
1341
1342 {
1343 wxListBars list1;
1344 list1.Append(new Bar(_T("first")));
1345 list1.Append(new Bar(_T("second")));
1346
1347 wxPrintf(_T("After 1st list creation: %u objects in the list, %u objects total.\n"),
1348 list1.GetCount(), Bar::GetNumber());
1349
1350 wxListBars list2;
1351 list2 = list1;
1352
1353 wxPrintf(_T("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n"),
1354 list1.GetCount(), list2.GetCount(), Bar::GetNumber());
1355
1356 list1.DeleteContents(TRUE);
1357 }
1358
1359 wxPrintf(_T("After list destruction: %u objects left.\n"), Bar::GetNumber());
1360 }
1361
1362 #endif // TEST_LIST
1363
1364 // ----------------------------------------------------------------------------
1365 // wxLocale
1366 // ----------------------------------------------------------------------------
1367
1368 #ifdef TEST_LOCALE
1369
1370 #include "wx/intl.h"
1371 #include "wx/utils.h" // for wxSetEnv
1372
1373 static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
1374
1375 // find the name of the language from its value
1376 static const wxChar *GetLangName(int lang)
1377 {
1378 static const wxChar *languageNames[] =
1379 {
1380 _T("DEFAULT"),
1381 _T("UNKNOWN"),
1382 _T("ABKHAZIAN"),
1383 _T("AFAR"),
1384 _T("AFRIKAANS"),
1385 _T("ALBANIAN"),
1386 _T("AMHARIC"),
1387 _T("ARABIC"),
1388 _T("ARABIC_ALGERIA"),
1389 _T("ARABIC_BAHRAIN"),
1390 _T("ARABIC_EGYPT"),
1391 _T("ARABIC_IRAQ"),
1392 _T("ARABIC_JORDAN"),
1393 _T("ARABIC_KUWAIT"),
1394 _T("ARABIC_LEBANON"),
1395 _T("ARABIC_LIBYA"),
1396 _T("ARABIC_MOROCCO"),
1397 _T("ARABIC_OMAN"),
1398 _T("ARABIC_QATAR"),
1399 _T("ARABIC_SAUDI_ARABIA"),
1400 _T("ARABIC_SUDAN"),
1401 _T("ARABIC_SYRIA"),
1402 _T("ARABIC_TUNISIA"),
1403 _T("ARABIC_UAE"),
1404 _T("ARABIC_YEMEN"),
1405 _T("ARMENIAN"),
1406 _T("ASSAMESE"),
1407 _T("AYMARA"),
1408 _T("AZERI"),
1409 _T("AZERI_CYRILLIC"),
1410 _T("AZERI_LATIN"),
1411 _T("BASHKIR"),
1412 _T("BASQUE"),
1413 _T("BELARUSIAN"),
1414 _T("BENGALI"),
1415 _T("BHUTANI"),
1416 _T("BIHARI"),
1417 _T("BISLAMA"),
1418 _T("BRETON"),
1419 _T("BULGARIAN"),
1420 _T("BURMESE"),
1421 _T("CAMBODIAN"),
1422 _T("CATALAN"),
1423 _T("CHINESE"),
1424 _T("CHINESE_SIMPLIFIED"),
1425 _T("CHINESE_TRADITIONAL"),
1426 _T("CHINESE_HONGKONG"),
1427 _T("CHINESE_MACAU"),
1428 _T("CHINESE_SINGAPORE"),
1429 _T("CHINESE_TAIWAN"),
1430 _T("CORSICAN"),
1431 _T("CROATIAN"),
1432 _T("CZECH"),
1433 _T("DANISH"),
1434 _T("DUTCH"),
1435 _T("DUTCH_BELGIAN"),
1436 _T("ENGLISH"),
1437 _T("ENGLISH_UK"),
1438 _T("ENGLISH_US"),
1439 _T("ENGLISH_AUSTRALIA"),
1440 _T("ENGLISH_BELIZE"),
1441 _T("ENGLISH_BOTSWANA"),
1442 _T("ENGLISH_CANADA"),
1443 _T("ENGLISH_CARIBBEAN"),
1444 _T("ENGLISH_DENMARK"),
1445 _T("ENGLISH_EIRE"),
1446 _T("ENGLISH_JAMAICA"),
1447 _T("ENGLISH_NEW_ZEALAND"),
1448 _T("ENGLISH_PHILIPPINES"),
1449 _T("ENGLISH_SOUTH_AFRICA"),
1450 _T("ENGLISH_TRINIDAD"),
1451 _T("ENGLISH_ZIMBABWE"),
1452 _T("ESPERANTO"),
1453 _T("ESTONIAN"),
1454 _T("FAEROESE"),
1455 _T("FARSI"),
1456 _T("FIJI"),
1457 _T("FINNISH"),
1458 _T("FRENCH"),
1459 _T("FRENCH_BELGIAN"),
1460 _T("FRENCH_CANADIAN"),
1461 _T("FRENCH_LUXEMBOURG"),
1462 _T("FRENCH_MONACO"),
1463 _T("FRENCH_SWISS"),
1464 _T("FRISIAN"),
1465 _T("GALICIAN"),
1466 _T("GEORGIAN"),
1467 _T("GERMAN"),
1468 _T("GERMAN_AUSTRIAN"),
1469 _T("GERMAN_BELGIUM"),
1470 _T("GERMAN_LIECHTENSTEIN"),
1471 _T("GERMAN_LUXEMBOURG"),
1472 _T("GERMAN_SWISS"),
1473 _T("GREEK"),
1474 _T("GREENLANDIC"),
1475 _T("GUARANI"),
1476 _T("GUJARATI"),
1477 _T("HAUSA"),
1478 _T("HEBREW"),
1479 _T("HINDI"),
1480 _T("HUNGARIAN"),
1481 _T("ICELANDIC"),
1482 _T("INDONESIAN"),
1483 _T("INTERLINGUA"),
1484 _T("INTERLINGUE"),
1485 _T("INUKTITUT"),
1486 _T("INUPIAK"),
1487 _T("IRISH"),
1488 _T("ITALIAN"),
1489 _T("ITALIAN_SWISS"),
1490 _T("JAPANESE"),
1491 _T("JAVANESE"),
1492 _T("KANNADA"),
1493 _T("KASHMIRI"),
1494 _T("KASHMIRI_INDIA"),
1495 _T("KAZAKH"),
1496 _T("KERNEWEK"),
1497 _T("KINYARWANDA"),
1498 _T("KIRGHIZ"),
1499 _T("KIRUNDI"),
1500 _T("KONKANI"),
1501 _T("KOREAN"),
1502 _T("KURDISH"),
1503 _T("LAOTHIAN"),
1504 _T("LATIN"),
1505 _T("LATVIAN"),
1506 _T("LINGALA"),
1507 _T("LITHUANIAN"),
1508 _T("MACEDONIAN"),
1509 _T("MALAGASY"),
1510 _T("MALAY"),
1511 _T("MALAYALAM"),
1512 _T("MALAY_BRUNEI_DARUSSALAM"),
1513 _T("MALAY_MALAYSIA"),
1514 _T("MALTESE"),
1515 _T("MANIPURI"),
1516 _T("MAORI"),
1517 _T("MARATHI"),
1518 _T("MOLDAVIAN"),
1519 _T("MONGOLIAN"),
1520 _T("NAURU"),
1521 _T("NEPALI"),
1522 _T("NEPALI_INDIA"),
1523 _T("NORWEGIAN_BOKMAL"),
1524 _T("NORWEGIAN_NYNORSK"),
1525 _T("OCCITAN"),
1526 _T("ORIYA"),
1527 _T("OROMO"),
1528 _T("PASHTO"),
1529 _T("POLISH"),
1530 _T("PORTUGUESE"),
1531 _T("PORTUGUESE_BRAZILIAN"),
1532 _T("PUNJABI"),
1533 _T("QUECHUA"),
1534 _T("RHAETO_ROMANCE"),
1535 _T("ROMANIAN"),
1536 _T("RUSSIAN"),
1537 _T("RUSSIAN_UKRAINE"),
1538 _T("SAMOAN"),
1539 _T("SANGHO"),
1540 _T("SANSKRIT"),
1541 _T("SCOTS_GAELIC"),
1542 _T("SERBIAN"),
1543 _T("SERBIAN_CYRILLIC"),
1544 _T("SERBIAN_LATIN"),
1545 _T("SERBO_CROATIAN"),
1546 _T("SESOTHO"),
1547 _T("SETSWANA"),
1548 _T("SHONA"),
1549 _T("SINDHI"),
1550 _T("SINHALESE"),
1551 _T("SISWATI"),
1552 _T("SLOVAK"),
1553 _T("SLOVENIAN"),
1554 _T("SOMALI"),
1555 _T("SPANISH"),
1556 _T("SPANISH_ARGENTINA"),
1557 _T("SPANISH_BOLIVIA"),
1558 _T("SPANISH_CHILE"),
1559 _T("SPANISH_COLOMBIA"),
1560 _T("SPANISH_COSTA_RICA"),
1561 _T("SPANISH_DOMINICAN_REPUBLIC"),
1562 _T("SPANISH_ECUADOR"),
1563 _T("SPANISH_EL_SALVADOR"),
1564 _T("SPANISH_GUATEMALA"),
1565 _T("SPANISH_HONDURAS"),
1566 _T("SPANISH_MEXICAN"),
1567 _T("SPANISH_MODERN"),
1568 _T("SPANISH_NICARAGUA"),
1569 _T("SPANISH_PANAMA"),
1570 _T("SPANISH_PARAGUAY"),
1571 _T("SPANISH_PERU"),
1572 _T("SPANISH_PUERTO_RICO"),
1573 _T("SPANISH_URUGUAY"),
1574 _T("SPANISH_US"),
1575 _T("SPANISH_VENEZUELA"),
1576 _T("SUNDANESE"),
1577 _T("SWAHILI"),
1578 _T("SWEDISH"),
1579 _T("SWEDISH_FINLAND"),
1580 _T("TAGALOG"),
1581 _T("TAJIK"),
1582 _T("TAMIL"),
1583 _T("TATAR"),
1584 _T("TELUGU"),
1585 _T("THAI"),
1586 _T("TIBETAN"),
1587 _T("TIGRINYA"),
1588 _T("TONGA"),
1589 _T("TSONGA"),
1590 _T("TURKISH"),
1591 _T("TURKMEN"),
1592 _T("TWI"),
1593 _T("UIGHUR"),
1594 _T("UKRAINIAN"),
1595 _T("URDU"),
1596 _T("URDU_INDIA"),
1597 _T("URDU_PAKISTAN"),
1598 _T("UZBEK"),
1599 _T("UZBEK_CYRILLIC"),
1600 _T("UZBEK_LATIN"),
1601 _T("VIETNAMESE"),
1602 _T("VOLAPUK"),
1603 _T("WELSH"),
1604 _T("WOLOF"),
1605 _T("XHOSA"),
1606 _T("YIDDISH"),
1607 _T("YORUBA"),
1608 _T("ZHUANG"),
1609 _T("ZULU"),
1610 };
1611
1612 if ( (size_t)lang < WXSIZEOF(languageNames) )
1613 return languageNames[lang];
1614 else
1615 return _T("INVALID");
1616 }
1617
1618 static void TestDefaultLang()
1619 {
1620 wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
1621
1622 static const wxChar *langStrings[] =
1623 {
1624 NULL, // system default
1625 _T("C"),
1626 _T("fr"),
1627 _T("fr_FR"),
1628 _T("en"),
1629 _T("en_GB"),
1630 _T("en_US"),
1631 _T("de_DE.iso88591"),
1632 _T("german"),
1633 _T("?"), // invalid lang spec
1634 _T("klingonese"), // I bet on some systems it does exist...
1635 };
1636
1637 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1638 wxLocale::GetSystemEncodingName().c_str(),
1639 wxLocale::GetSystemEncoding());
1640
1641 for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1642 {
1643 const wxChar *langStr = langStrings[n];
1644 if ( langStr )
1645 {
1646 // FIXME: this doesn't do anything at all under Windows, we need
1647 // to create a new wxLocale!
1648 wxSetEnv(_T("LC_ALL"), langStr);
1649 }
1650
1651 int lang = gs_localeDefault.GetSystemLanguage();
1652 wxPrintf(_T("Locale for '%s' is %s.\n"),
1653 langStr ? langStr : _T("system default"), GetLangName(lang));
1654 }
1655 }
1656
1657 #endif // TEST_LOCALE
1658
1659 // ----------------------------------------------------------------------------
1660 // MIME types
1661 // ----------------------------------------------------------------------------
1662
1663 #ifdef TEST_MIME
1664
1665 #include "wx/mimetype.h"
1666
1667 static void TestMimeEnum()
1668 {
1669 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1670
1671 wxArrayString mimetypes;
1672
1673 size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1674
1675 wxPrintf(_T("*** All %u known filetypes: ***\n"), count);
1676
1677 wxArrayString exts;
1678 wxString desc;
1679
1680 for ( size_t n = 0; n < count; n++ )
1681 {
1682 wxFileType *filetype =
1683 wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1684 if ( !filetype )
1685 {
1686 wxPrintf(_T("nothing known about the filetype '%s'!\n"),
1687 mimetypes[n].c_str());
1688 continue;
1689 }
1690
1691 filetype->GetDescription(&desc);
1692 filetype->GetExtensions(exts);
1693
1694 filetype->GetIcon(NULL);
1695
1696 wxString extsAll;
1697 for ( size_t e = 0; e < exts.GetCount(); e++ )
1698 {
1699 if ( e > 0 )
1700 extsAll << _T(", ");
1701 extsAll += exts[e];
1702 }
1703
1704 wxPrintf(_T("\t%s: %s (%s)\n"),
1705 mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1706 }
1707
1708 wxPuts(_T(""));
1709 }
1710
1711 static void TestMimeOverride()
1712 {
1713 wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1714
1715 static const wxChar *mailcap = _T("/tmp/mailcap");
1716 static const wxChar *mimetypes = _T("/tmp/mime.types");
1717
1718 if ( wxFile::Exists(mailcap) )
1719 wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1720 mailcap,
1721 wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
1722 else
1723 wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1724 mailcap);
1725
1726 if ( wxFile::Exists(mimetypes) )
1727 wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1728 mimetypes,
1729 wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
1730 else
1731 wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1732 mimetypes);
1733
1734 wxPuts(_T(""));
1735 }
1736
1737 static void TestMimeFilename()
1738 {
1739 wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1740
1741 static const wxChar *filenames[] =
1742 {
1743 _T("readme.txt"),
1744 _T("document.pdf"),
1745 _T("image.gif"),
1746 _T("picture.jpeg"),
1747 };
1748
1749 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1750 {
1751 const wxString fname = filenames[n];
1752 wxString ext = fname.AfterLast(_T('.'));
1753 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1754 if ( !ft )
1755 {
1756 wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1757 }
1758 else
1759 {
1760 wxString desc;
1761 if ( !ft->GetDescription(&desc) )
1762 desc = _T("<no description>");
1763
1764 wxString cmd;
1765 if ( !ft->GetOpenCommand(&cmd,
1766 wxFileType::MessageParameters(fname, _T(""))) )
1767 cmd = _T("<no command available>");
1768 else
1769 cmd = wxString('"') + cmd + '"';
1770
1771 wxPrintf(_T("To open %s (%s) do %s.\n"),
1772 fname.c_str(), desc.c_str(), cmd.c_str());
1773
1774 delete ft;
1775 }
1776 }
1777
1778 wxPuts(_T(""));
1779 }
1780
1781 static void TestMimeAssociate()
1782 {
1783 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1784
1785 wxFileTypeInfo ftInfo(
1786 _T("application/x-xyz"),
1787 _T("xyzview '%s'"), // open cmd
1788 _T(""), // print cmd
1789 _T("XYZ File"), // description
1790 _T(".xyz"), // extensions
1791 NULL // end of extensions
1792 );
1793 ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1794
1795 wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1796 if ( !ft )
1797 {
1798 wxPuts(_T("ERROR: failed to create association!"));
1799 }
1800 else
1801 {
1802 // TODO: read it back
1803 delete ft;
1804 }
1805
1806 wxPuts(_T(""));
1807 }
1808
1809 #endif // TEST_MIME
1810
1811 // ----------------------------------------------------------------------------
1812 // misc information functions
1813 // ----------------------------------------------------------------------------
1814
1815 #ifdef TEST_INFO_FUNCTIONS
1816
1817 #include "wx/utils.h"
1818
1819 static void TestDiskInfo()
1820 {
1821 wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
1822
1823 for ( ;; )
1824 {
1825 wxChar pathname[128];
1826 wxPrintf(_T("\nEnter a directory name: "));
1827 if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
1828 break;
1829
1830 // kill the last '\n'
1831 pathname[wxStrlen(pathname) - 1] = 0;
1832
1833 wxLongLong total, free;
1834 if ( !wxGetDiskSpace(pathname, &total, &free) )
1835 {
1836 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1837 }
1838 else
1839 {
1840 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1841 (total / 1024).ToString().c_str(),
1842 (free / 1024).ToString().c_str(),
1843 pathname);
1844 }
1845 }
1846 }
1847
1848 static void TestOsInfo()
1849 {
1850 wxPuts(_T("*** Testing OS info functions ***\n"));
1851
1852 int major, minor;
1853 wxGetOsVersion(&major, &minor);
1854 wxPrintf(_T("Running under: %s, version %d.%d\n"),
1855 wxGetOsDescription().c_str(), major, minor);
1856
1857 wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory());
1858
1859 wxPrintf(_T("Host name is %s (%s).\n"),
1860 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1861
1862 wxPuts(_T(""));
1863 }
1864
1865 static void TestUserInfo()
1866 {
1867 wxPuts(_T("*** Testing user info functions ***\n"));
1868
1869 wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
1870 wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
1871 wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
1872 wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
1873
1874 wxPuts(_T(""));
1875 }
1876
1877 #endif // TEST_INFO_FUNCTIONS
1878
1879 // ----------------------------------------------------------------------------
1880 // long long
1881 // ----------------------------------------------------------------------------
1882
1883 #ifdef TEST_LONGLONG
1884
1885 #include "wx/longlong.h"
1886 #include "wx/timer.h"
1887
1888 // make a 64 bit number from 4 16 bit ones
1889 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
1890
1891 // get a random 64 bit number
1892 #define RAND_LL() MAKE_LL(rand(), rand(), rand(), rand())
1893
1894 static const long testLongs[] =
1895 {
1896 0,
1897 1,
1898 -1,
1899 LONG_MAX,
1900 LONG_MIN,
1901 0x1234,
1902 -0x1234
1903 };
1904
1905 #if wxUSE_LONGLONG_WX
1906 inline bool operator==(const wxLongLongWx& a, const wxLongLongNative& b)
1907 { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
1908 inline bool operator==(const wxLongLongNative& a, const wxLongLongWx& b)
1909 { return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
1910 #endif // wxUSE_LONGLONG_WX
1911
1912 static void TestSpeed()
1913 {
1914 static const long max = 100000000;
1915 long n;
1916
1917 {
1918 wxStopWatch sw;
1919
1920 long l = 0;
1921 for ( n = 0; n < max; n++ )
1922 {
1923 l += n;
1924 }
1925
1926 wxPrintf(_T("Summing longs took %ld milliseconds.\n"), sw.Time());
1927 }
1928
1929 #if wxUSE_LONGLONG_NATIVE
1930 {
1931 wxStopWatch sw;
1932
1933 wxLongLong_t l = 0;
1934 for ( n = 0; n < max; n++ )
1935 {
1936 l += n;
1937 }
1938
1939 wxPrintf(_T("Summing wxLongLong_t took %ld milliseconds.\n"), sw.Time());
1940 }
1941 #endif // wxUSE_LONGLONG_NATIVE
1942
1943 {
1944 wxStopWatch sw;
1945
1946 wxLongLong l;
1947 for ( n = 0; n < max; n++ )
1948 {
1949 l += n;
1950 }
1951
1952 wxPrintf(_T("Summing wxLongLongs took %ld milliseconds.\n"), sw.Time());
1953 }
1954 }
1955
1956 static void TestLongLongConversion()
1957 {
1958 wxPuts(_T("*** Testing wxLongLong conversions ***\n"));
1959
1960 wxLongLong a;
1961 size_t nTested = 0;
1962 for ( size_t n = 0; n < 100000; n++ )
1963 {
1964 a = RAND_LL();
1965
1966 #if wxUSE_LONGLONG_NATIVE
1967 wxLongLongNative b(a.GetHi(), a.GetLo());
1968
1969 wxASSERT_MSG( a == b, "conversions failure" );
1970 #else
1971 wxPuts(_T("Can't do it without native long long type, test skipped."));
1972
1973 return;
1974 #endif // wxUSE_LONGLONG_NATIVE
1975
1976 if ( !(nTested % 1000) )
1977 {
1978 putchar('.');
1979 fflush(stdout);
1980 }
1981
1982 nTested++;
1983 }
1984
1985 wxPuts(_T(" done!"));
1986 }
1987
1988 static void TestMultiplication()
1989 {
1990 wxPuts(_T("*** Testing wxLongLong multiplication ***\n"));
1991
1992 wxLongLong a, b;
1993 size_t nTested = 0;
1994 for ( size_t n = 0; n < 100000; n++ )
1995 {
1996 a = RAND_LL();
1997 b = RAND_LL();
1998
1999 #if wxUSE_LONGLONG_NATIVE
2000 wxLongLongNative aa(a.GetHi(), a.GetLo());
2001 wxLongLongNative bb(b.GetHi(), b.GetLo());
2002
2003 wxASSERT_MSG( a*b == aa*bb, "multiplication failure" );
2004 #else // !wxUSE_LONGLONG_NATIVE
2005 wxPuts(_T("Can't do it without native long long type, test skipped."));
2006
2007 return;
2008 #endif // wxUSE_LONGLONG_NATIVE
2009
2010 if ( !(nTested % 1000) )
2011 {
2012 putchar('.');
2013 fflush(stdout);
2014 }
2015
2016 nTested++;
2017 }
2018
2019 wxPuts(_T(" done!"));
2020 }
2021
2022 static void TestDivision()
2023 {
2024 wxPuts(_T("*** Testing wxLongLong division ***\n"));
2025
2026 wxLongLong q, r;
2027 size_t nTested = 0;
2028 for ( size_t n = 0; n < 100000; n++ )
2029 {
2030 // get a random wxLongLong (shifting by 12 the MSB ensures that the
2031 // multiplication will not overflow)
2032 wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
2033
2034 // get a random (but non null) long (not wxLongLong for now) to divide
2035 // it with
2036 long l;
2037 do
2038 {
2039 l = rand();
2040 }
2041 while ( !l );
2042
2043 q = ll / l;
2044 r = ll % l;
2045
2046 #if wxUSE_LONGLONG_NATIVE
2047 wxLongLongNative m(ll.GetHi(), ll.GetLo());
2048
2049 wxLongLongNative p = m / l, s = m % l;
2050 wxASSERT_MSG( q == p && r == s, "division failure" );
2051 #else // !wxUSE_LONGLONG_NATIVE
2052 // verify the result
2053 wxASSERT_MSG( ll == q*l + r, "division failure" );
2054 #endif // wxUSE_LONGLONG_NATIVE
2055
2056 if ( !(nTested % 1000) )
2057 {
2058 putchar('.');
2059 fflush(stdout);
2060 }
2061
2062 nTested++;
2063 }
2064
2065 wxPuts(_T(" done!"));
2066 }
2067
2068 static void TestAddition()
2069 {
2070 wxPuts(_T("*** Testing wxLongLong addition ***\n"));
2071
2072 wxLongLong a, b, c;
2073 size_t nTested = 0;
2074 for ( size_t n = 0; n < 100000; n++ )
2075 {
2076 a = RAND_LL();
2077 b = RAND_LL();
2078 c = a + b;
2079
2080 #if wxUSE_LONGLONG_NATIVE
2081 wxASSERT_MSG( c == wxLongLongNative(a.GetHi(), a.GetLo()) +
2082 wxLongLongNative(b.GetHi(), b.GetLo()),
2083 "addition failure" );
2084 #else // !wxUSE_LONGLONG_NATIVE
2085 wxASSERT_MSG( c - b == a, "addition failure" );
2086 #endif // wxUSE_LONGLONG_NATIVE
2087
2088 if ( !(nTested % 1000) )
2089 {
2090 putchar('.');
2091 fflush(stdout);
2092 }
2093
2094 nTested++;
2095 }
2096
2097 wxPuts(_T(" done!"));
2098 }
2099
2100 static void TestBitOperations()
2101 {
2102 wxPuts(_T("*** Testing wxLongLong bit operation ***\n"));
2103
2104 wxLongLong ll;
2105 size_t nTested = 0;
2106 for ( size_t n = 0; n < 100000; n++ )
2107 {
2108 ll = RAND_LL();
2109
2110 #if wxUSE_LONGLONG_NATIVE
2111 for ( size_t n = 0; n < 33; n++ )
2112 {
2113 }
2114 #else // !wxUSE_LONGLONG_NATIVE
2115 wxPuts(_T("Can't do it without native long long type, test skipped."));
2116
2117 return;
2118 #endif // wxUSE_LONGLONG_NATIVE
2119
2120 if ( !(nTested % 1000) )
2121 {
2122 putchar('.');
2123 fflush(stdout);
2124 }
2125
2126 nTested++;
2127 }
2128
2129 wxPuts(_T(" done!"));
2130 }
2131
2132 static void TestLongLongComparison()
2133 {
2134 #if wxUSE_LONGLONG_WX
2135 wxPuts(_T("*** Testing wxLongLong comparison ***\n"));
2136
2137 static const long ls[2] =
2138 {
2139 0x1234,
2140 -0x1234,
2141 };
2142
2143 wxLongLongWx lls[2];
2144 lls[0] = ls[0];
2145 lls[1] = ls[1];
2146
2147 for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
2148 {
2149 bool res;
2150
2151 for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
2152 {
2153 res = lls[m] > testLongs[n];
2154 wxPrintf(_T("0x%lx > 0x%lx is %s (%s)\n"),
2155 ls[m], testLongs[n], res ? "true" : "false",
2156 res == (ls[m] > testLongs[n]) ? "ok" : "ERROR");
2157
2158 res = lls[m] < testLongs[n];
2159 wxPrintf(_T("0x%lx < 0x%lx is %s (%s)\n"),
2160 ls[m], testLongs[n], res ? "true" : "false",
2161 res == (ls[m] < testLongs[n]) ? "ok" : "ERROR");
2162
2163 res = lls[m] == testLongs[n];
2164 wxPrintf(_T("0x%lx == 0x%lx is %s (%s)\n"),
2165 ls[m], testLongs[n], res ? "true" : "false",
2166 res == (ls[m] == testLongs[n]) ? "ok" : "ERROR");
2167 }
2168 }
2169 #endif // wxUSE_LONGLONG_WX
2170 }
2171
2172 static void TestLongLongPrint()
2173 {
2174 wxPuts(_T("*** Testing wxLongLong printing ***\n"));
2175
2176 for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
2177 {
2178 wxLongLong ll = testLongs[n];
2179 wxPrintf(_T("%ld == %s\n"), testLongs[n], ll.ToString().c_str());
2180 }
2181
2182 wxLongLong ll(0x12345678, 0x87654321);
2183 wxPrintf(_T("0x1234567887654321 = %s\n"), ll.ToString().c_str());
2184
2185 ll.Negate();
2186 wxPrintf(_T("-0x1234567887654321 = %s\n"), ll.ToString().c_str());
2187 }
2188
2189 static void TestLongLongPrintf()
2190 {
2191 wxPuts(_T("*** Testing wxLongLong printing ***\n"));
2192
2193 #ifdef wxLongLongFmtSpec
2194 wxLongLong ll = wxLL(0x1234567890abcdef);
2195 wxString s = wxString::Format(_T("%") wxLongLongFmtSpec _T("x"),
2196 ll.GetValue());
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("%07Lo"), (wxLongLong_t)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 textInUtf8_[] =
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 #define textInUtf8 ((const char *)textInUtf8_)
3888
3889 static void TestUtf8()
3890 {
3891 wxPuts(_T("*** Testing UTF8 support ***\n"));
3892
3893 char buf[1024];
3894 wchar_t wbuf[1024];
3895 if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
3896 {
3897 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3898 }
3899 else
3900 {
3901 wxCSConv conv(_T("koi8-r"));
3902 if ( conv.WC2MB(buf, wbuf, 0 /* not needed wcslen(wbuf) */) <= 0 )
3903 {
3904 wxPuts(_T("ERROR: conversion to KOI8-R failed."));
3905 }
3906 else
3907 {
3908 wxPrintf(_T("The resulting string (in KOI8-R): %s\n"), buf);
3909 }
3910 }
3911
3912 if ( wxConvUTF8.WC2MB(buf, L"à la", WXSIZEOF(buf)) <= 0 )
3913 {
3914 wxPuts(_T("ERROR: conversion to UTF-8 failed."));
3915 }
3916 else
3917 {
3918 wxPrintf(_T("The string in UTF-8: %s\n"), buf);
3919 }
3920
3921 wxPuts(_T(""));
3922 }
3923
3924 static void TestEncodingConverter()
3925 {
3926 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3927
3928 // using wxEncodingConverter should give the same result as above
3929 char buf[1024];
3930 wchar_t wbuf[1024];
3931 if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
3932 {
3933 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3934 }
3935 else
3936 {
3937 wxEncodingConverter ec;
3938 ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3939 ec.Convert(wbuf, buf);
3940 wxPrintf(_T("The same string obtained using wxEC: %s\n"), buf);
3941 }
3942
3943 wxPuts(_T(""));
3944 }
3945
3946 #endif // TEST_WCHAR
3947
3948 // ----------------------------------------------------------------------------
3949 // ZIP stream
3950 // ----------------------------------------------------------------------------
3951
3952 #ifdef TEST_ZIP
3953
3954 #include "wx/filesys.h"
3955 #include "wx/fs_zip.h"
3956 #include "wx/zipstrm.h"
3957
3958 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3959
3960 static void TestZipStreamRead()
3961 {
3962 wxPuts(_T("*** Testing ZIP reading ***\n"));
3963
3964 static const wxChar *filename = _T("foo");
3965 wxZipInputStream istr(TESTFILE_ZIP, filename);
3966 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
3967
3968 wxPrintf(_T("Dumping the file '%s':\n"), filename);
3969 while ( !istr.Eof() )
3970 {
3971 putchar(istr.GetC());
3972 fflush(stdout);
3973 }
3974
3975 wxPuts(_T("\n----- done ------"));
3976 }
3977
3978 static void DumpZipDirectory(wxFileSystem& fs,
3979 const wxString& dir,
3980 const wxString& indent)
3981 {
3982 wxString prefix = wxString::Format(_T("%s#zip:%s"),
3983 TESTFILE_ZIP, dir.c_str());
3984 wxString wildcard = prefix + _T("/*");
3985
3986 wxString dirname = fs.FindFirst(wildcard, wxDIR);
3987 while ( !dirname.empty() )
3988 {
3989 if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3990 {
3991 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3992
3993 break;
3994 }
3995
3996 wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3997
3998 DumpZipDirectory(fs, dirname,
3999 indent + wxString(_T(' '), 4));
4000
4001 dirname = fs.FindNext();
4002 }
4003
4004 wxString filename = fs.FindFirst(wildcard, wxFILE);
4005 while ( !filename.empty() )
4006 {
4007 if ( !filename.StartsWith(prefix, &filename) )
4008 {
4009 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
4010
4011 break;
4012 }
4013
4014 wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
4015
4016 filename = fs.FindNext();
4017 }
4018 }
4019
4020 static void TestZipFileSystem()
4021 {
4022 wxPuts(_T("*** Testing ZIP file system ***\n"));
4023
4024 wxFileSystem::AddHandler(new wxZipFSHandler);
4025 wxFileSystem fs;
4026 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
4027
4028 DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
4029 }
4030
4031 #endif // TEST_ZIP
4032
4033 // ----------------------------------------------------------------------------
4034 // ZLIB stream
4035 // ----------------------------------------------------------------------------
4036
4037 #ifdef TEST_ZLIB
4038
4039 #include "wx/zstream.h"
4040 #include "wx/wfstream.h"
4041
4042 static const wxChar *FILENAME_GZ = _T("test.gz");
4043 static const wxChar *TEST_DATA = _T("hello and hello and hello and hello and hello");
4044
4045 static void TestZlibStreamWrite()
4046 {
4047 wxPuts(_T("*** Testing Zlib stream reading ***\n"));
4048
4049 wxFileOutputStream fileOutStream(FILENAME_GZ);
4050 wxZlibOutputStream ostr(fileOutStream);
4051 wxPrintf(_T("Compressing the test string... "));
4052 ostr.Write(TEST_DATA, wxStrlen(TEST_DATA) + 1);
4053 if ( !ostr )
4054 {
4055 wxPuts(_T("(ERROR: failed)"));
4056 }
4057 else
4058 {
4059 wxPuts(_T("(ok)"));
4060 }
4061
4062 wxPuts(_T("\n----- done ------"));
4063 }
4064
4065 static void TestZlibStreamRead()
4066 {
4067 wxPuts(_T("*** Testing Zlib stream reading ***\n"));
4068
4069 wxFileInputStream fileInStream(FILENAME_GZ);
4070 wxZlibInputStream istr(fileInStream);
4071 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
4072
4073 wxPuts(_T("Dumping the file:"));
4074 while ( !istr.Eof() )
4075 {
4076 putchar(istr.GetC());
4077 fflush(stdout);
4078 }
4079
4080 wxPuts(_T("\n----- done ------"));
4081 }
4082
4083 #endif // TEST_ZLIB
4084
4085 // ----------------------------------------------------------------------------
4086 // date time
4087 // ----------------------------------------------------------------------------
4088
4089 #ifdef TEST_DATETIME
4090
4091 #include <math.h>
4092
4093 #include "wx/date.h"
4094 #include "wx/datetime.h"
4095
4096 // the test data
4097 struct Date
4098 {
4099 wxDateTime::wxDateTime_t day;
4100 wxDateTime::Month month;
4101 int year;
4102 wxDateTime::wxDateTime_t hour, min, sec;
4103 double jdn;
4104 wxDateTime::WeekDay wday;
4105 time_t gmticks, ticks;
4106
4107 void Init(const wxDateTime::Tm& tm)
4108 {
4109 day = tm.mday;
4110 month = tm.mon;
4111 year = tm.year;
4112 hour = tm.hour;
4113 min = tm.min;
4114 sec = tm.sec;
4115 jdn = 0.0;
4116 gmticks = ticks = -1;
4117 }
4118
4119 wxDateTime DT() const
4120 { return wxDateTime(day, month, year, hour, min, sec); }
4121
4122 bool SameDay(const wxDateTime::Tm& tm) const
4123 {
4124 return day == tm.mday && month == tm.mon && year == tm.year;
4125 }
4126
4127 wxString Format() const
4128 {
4129 wxString s;
4130 s.Printf(_T("%02d:%02d:%02d %10s %02d, %4d%s"),
4131 hour, min, sec,
4132 wxDateTime::GetMonthName(month).c_str(),
4133 day,
4134 abs(wxDateTime::ConvertYearToBC(year)),
4135 year > 0 ? _T("AD") : _T("BC"));
4136 return s;
4137 }
4138
4139 wxString FormatDate() const
4140 {
4141 wxString s;
4142 s.Printf(_T("%02d-%s-%4d%s"),
4143 day,
4144 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
4145 abs(wxDateTime::ConvertYearToBC(year)),
4146 year > 0 ? _T("AD") : _T("BC"));
4147 return s;
4148 }
4149 };
4150
4151 static const Date testDates[] =
4152 {
4153 { 1, wxDateTime::Jan, 1970, 00, 00, 00, 2440587.5, wxDateTime::Thu, 0, -3600 },
4154 { 7, wxDateTime::Feb, 2036, 00, 00, 00, 2464730.5, wxDateTime::Thu, -1, -1 },
4155 { 8, wxDateTime::Feb, 2036, 00, 00, 00, 2464731.5, wxDateTime::Fri, -1, -1 },
4156 { 1, wxDateTime::Jan, 2037, 00, 00, 00, 2465059.5, wxDateTime::Thu, -1, -1 },
4157 { 1, wxDateTime::Jan, 2038, 00, 00, 00, 2465424.5, wxDateTime::Fri, -1, -1 },
4158 { 21, wxDateTime::Jan, 2222, 00, 00, 00, 2532648.5, wxDateTime::Mon, -1, -1 },
4159 { 29, wxDateTime::May, 1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
4160 { 29, wxDateTime::Feb, 1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
4161 { 1, wxDateTime::Jan, 1900, 12, 00, 00, 2415021.0, wxDateTime::Mon, -1, -1 },
4162 { 1, wxDateTime::Jan, 1900, 00, 00, 00, 2415020.5, wxDateTime::Mon, -1, -1 },
4163 { 15, wxDateTime::Oct, 1582, 00, 00, 00, 2299160.5, wxDateTime::Fri, -1, -1 },
4164 { 4, wxDateTime::Oct, 1582, 00, 00, 00, 2299149.5, wxDateTime::Mon, -1, -1 },
4165 { 1, wxDateTime::Mar, 1, 00, 00, 00, 1721484.5, wxDateTime::Thu, -1, -1 },
4166 { 1, wxDateTime::Jan, 1, 00, 00, 00, 1721425.5, wxDateTime::Mon, -1, -1 },
4167 { 31, wxDateTime::Dec, 0, 00, 00, 00, 1721424.5, wxDateTime::Sun, -1, -1 },
4168 { 1, wxDateTime::Jan, 0, 00, 00, 00, 1721059.5, wxDateTime::Sat, -1, -1 },
4169 { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri, -1, -1 },
4170 { 12, wxDateTime::Aug, -4000, 00, 00, 00, 260313.5, wxDateTime::Sat, -1, -1 },
4171 { 24, wxDateTime::Nov, -4713, 00, 00, 00, -0.5, wxDateTime::Mon, -1, -1 },
4172 };
4173
4174 // this test miscellaneous static wxDateTime functions
4175 static void TestTimeStatic()
4176 {
4177 wxPuts(_T("\n*** wxDateTime static methods test ***"));
4178
4179 // some info about the current date
4180 int year = wxDateTime::GetCurrentYear();
4181 wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
4182 year,
4183 wxDateTime::IsLeapYear(year) ? "" : "not ",
4184 wxDateTime::GetNumberOfDays(year));
4185
4186 wxDateTime::Month month = wxDateTime::GetCurrentMonth();
4187 wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
4188 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
4189 wxDateTime::GetMonthName(month).c_str(),
4190 wxDateTime::GetNumberOfDays(month));
4191
4192 // leap year logic
4193 static const size_t nYears = 5;
4194 static const size_t years[2][nYears] =
4195 {
4196 // first line: the years to test
4197 { 1990, 1976, 2000, 2030, 1984, },
4198
4199 // second line: TRUE if leap, FALSE otherwise
4200 { FALSE, TRUE, TRUE, FALSE, TRUE }
4201 };
4202
4203 for ( size_t n = 0; n < nYears; n++ )
4204 {
4205 int year = years[0][n];
4206 bool should = years[1][n] != 0,
4207 is = wxDateTime::IsLeapYear(year);
4208
4209 wxPrintf(_T("Year %d is %sa leap year (%s)\n"),
4210 year,
4211 is ? "" : "not ",
4212 should == is ? "ok" : "ERROR");
4213
4214 wxASSERT( should == wxDateTime::IsLeapYear(year) );
4215 }
4216 }
4217
4218 // test constructing wxDateTime objects
4219 static void TestTimeSet()
4220 {
4221 wxPuts(_T("\n*** wxDateTime construction test ***"));
4222
4223 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4224 {
4225 const Date& d1 = testDates[n];
4226 wxDateTime dt = d1.DT();
4227
4228 Date d2;
4229 d2.Init(dt.GetTm());
4230
4231 wxString s1 = d1.Format(),
4232 s2 = d2.Format();
4233
4234 wxPrintf(_T("Date: %s == %s (%s)\n"),
4235 s1.c_str(), s2.c_str(),
4236 s1 == s2 ? _T("ok") : _T("ERROR"));
4237 }
4238 }
4239
4240 // test time zones stuff
4241 static void TestTimeZones()
4242 {
4243 wxPuts(_T("\n*** wxDateTime timezone test ***"));
4244
4245 wxDateTime now = wxDateTime::Now();
4246
4247 wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
4248 wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
4249 wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
4250 wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
4251 wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
4252 wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
4253
4254 wxDateTime::Tm tm = now.GetTm();
4255 if ( wxDateTime(tm) != now )
4256 {
4257 wxPrintf(_T("ERROR: got %s instead of %s\n"),
4258 wxDateTime(tm).Format().c_str(), now.Format().c_str());
4259 }
4260 }
4261
4262 // test some minimal support for the dates outside the standard range
4263 static void TestTimeRange()
4264 {
4265 wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
4266
4267 static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
4268
4269 wxPrintf(_T("Unix epoch:\t%s\n"),
4270 wxDateTime(2440587.5).Format(fmt).c_str());
4271 wxPrintf(_T("Feb 29, 0: \t%s\n"),
4272 wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
4273 wxPrintf(_T("JDN 0: \t%s\n"),
4274 wxDateTime(0.0).Format(fmt).c_str());
4275 wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
4276 wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
4277 wxPrintf(_T("May 29, 2099:\t%s\n"),
4278 wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
4279 }
4280
4281 static void TestTimeTicks()
4282 {
4283 wxPuts(_T("\n*** wxDateTime ticks test ***"));
4284
4285 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4286 {
4287 const Date& d = testDates[n];
4288 if ( d.ticks == -1 )
4289 continue;
4290
4291 wxDateTime dt = d.DT();
4292 long ticks = (dt.GetValue() / 1000).ToLong();
4293 wxPrintf(_T("Ticks of %s:\t% 10ld"), d.Format().c_str(), ticks);
4294 if ( ticks == d.ticks )
4295 {
4296 wxPuts(_T(" (ok)"));
4297 }
4298 else
4299 {
4300 wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
4301 (long)d.ticks, (long)(ticks - d.ticks));
4302 }
4303
4304 dt = d.DT().ToTimezone(wxDateTime::GMT0);
4305 ticks = (dt.GetValue() / 1000).ToLong();
4306 wxPrintf(_T("GMtks of %s:\t% 10ld"), d.Format().c_str(), ticks);
4307 if ( ticks == d.gmticks )
4308 {
4309 wxPuts(_T(" (ok)"));
4310 }
4311 else
4312 {
4313 wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
4314 (long)d.gmticks, (long)(ticks - d.gmticks));
4315 }
4316 }
4317
4318 wxPuts(_T(""));
4319 }
4320
4321 // test conversions to JDN &c
4322 static void TestTimeJDN()
4323 {
4324 wxPuts(_T("\n*** wxDateTime to JDN test ***"));
4325
4326 for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
4327 {
4328 const Date& d = testDates[n];
4329 wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
4330 double jdn = dt.GetJulianDayNumber();
4331
4332 wxPrintf(_T("JDN of %s is:\t% 15.6f"), d.Format().c_str(), jdn);
4333 if ( jdn == d.jdn )
4334 {
4335 wxPuts(_T(" (ok)"));
4336 }
4337 else
4338 {
4339 wxPrintf(_T(" (ERROR: should be %f, delta = %f)\n"),
4340 d.jdn, jdn - d.jdn);
4341 }
4342 }
4343 }
4344
4345 // test week days computation
4346 static void TestTimeWDays()
4347 {
4348 wxPuts(_T("\n*** wxDateTime weekday test ***"));
4349
4350 // test GetWeekDay()
4351 size_t n;
4352 for ( n = 0; n < WXSIZEOF(testDates); n++ )
4353 {
4354 const Date& d = testDates[n];
4355 wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
4356
4357 wxDateTime::WeekDay wday = dt.GetWeekDay();
4358 wxPrintf(_T("%s is: %s"),
4359 d.Format().c_str(),
4360 wxDateTime::GetWeekDayName(wday).c_str());
4361 if ( wday == d.wday )
4362 {
4363 wxPuts(_T(" (ok)"));
4364 }
4365 else
4366 {
4367 wxPrintf(_T(" (ERROR: should be %s)\n"),
4368 wxDateTime::GetWeekDayName(d.wday).c_str());
4369 }
4370 }
4371
4372 wxPuts(_T(""));
4373
4374 // test SetToWeekDay()
4375 struct WeekDateTestData
4376 {
4377 Date date; // the real date (precomputed)
4378 int nWeek; // its week index in the month
4379 wxDateTime::WeekDay wday; // the weekday
4380 wxDateTime::Month month; // the month
4381 int year; // and the year
4382
4383 wxString Format() const
4384 {
4385 wxString s, which;
4386 switch ( nWeek < -1 ? -nWeek : nWeek )
4387 {
4388 case 1: which = _T("first"); break;
4389 case 2: which = _T("second"); break;
4390 case 3: which = _T("third"); break;
4391 case 4: which = _T("fourth"); break;
4392 case 5: which = _T("fifth"); break;
4393
4394 case -1: which = _T("last"); break;
4395 }
4396
4397 if ( nWeek < -1 )
4398 {
4399 which += _T(" from end");
4400 }
4401
4402 s.Printf(_T("The %s %s of %s in %d"),
4403 which.c_str(),
4404 wxDateTime::GetWeekDayName(wday).c_str(),
4405 wxDateTime::GetMonthName(month).c_str(),
4406 year);
4407
4408 return s;
4409 }
4410 };
4411
4412 // the array data was generated by the following python program
4413 /*
4414 from DateTime import *
4415 from whrandom import *
4416 from string import *
4417
4418 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4419 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4420
4421 week = DateTimeDelta(7)
4422
4423 for n in range(20):
4424 year = randint(1900, 2100)
4425 month = randint(1, 12)
4426 day = randint(1, 28)
4427 dt = DateTime(year, month, day)
4428 wday = dt.day_of_week
4429
4430 countFromEnd = choice([-1, 1])
4431 weekNum = 0;
4432
4433 while dt.month is month:
4434 dt = dt - countFromEnd * week
4435 weekNum = weekNum + countFromEnd
4436
4437 data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
4438
4439 print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
4440 "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
4441 */
4442
4443 static const WeekDateTestData weekDatesTestData[] =
4444 {
4445 { { 20, wxDateTime::Mar, 2045 }, 3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
4446 { { 5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
4447 { { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
4448 { { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
4449 { { 4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
4450 { { 2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
4451 { { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
4452 { { 5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
4453 { { 11, wxDateTime::Aug, 1900 }, 2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
4454 { { 14, wxDateTime::Feb, 1945 }, 2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
4455 { { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
4456 { { 9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
4457 { { 20, wxDateTime::Jun, 1927 }, 3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
4458 { { 2, wxDateTime::Aug, 2000 }, 1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
4459 { { 20, wxDateTime::Apr, 2044 }, 3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
4460 { { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
4461 { { 25, wxDateTime::Jul, 2069 }, 4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
4462 { { 3, wxDateTime::Apr, 1925 }, 1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
4463 { { 21, wxDateTime::Mar, 2093 }, 3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
4464 { { 3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
4465 };
4466
4467 static const wxChar *fmt = _T("%d-%b-%Y");
4468
4469 wxDateTime dt;
4470 for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
4471 {
4472 const WeekDateTestData& wd = weekDatesTestData[n];
4473
4474 dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
4475
4476 wxPrintf(_T("%s is %s"), wd.Format().c_str(), dt.Format(fmt).c_str());
4477
4478 const Date& d = wd.date;
4479 if ( d.SameDay(dt.GetTm()) )
4480 {
4481 wxPuts(_T(" (ok)"));
4482 }
4483 else
4484 {
4485 dt.Set(d.day, d.month, d.year);
4486
4487 wxPrintf(_T(" (ERROR: should be %s)\n"), dt.Format(fmt).c_str());
4488 }
4489 }
4490 }
4491
4492 // test the computation of (ISO) week numbers
4493 static void TestTimeWNumber()
4494 {
4495 wxPuts(_T("\n*** wxDateTime week number test ***"));
4496
4497 struct WeekNumberTestData
4498 {
4499 Date date; // the date
4500 wxDateTime::wxDateTime_t week; // the week number in the year
4501 wxDateTime::wxDateTime_t wmon; // the week number in the month
4502 wxDateTime::wxDateTime_t wmon2; // same but week starts with Sun
4503 wxDateTime::wxDateTime_t dnum; // day number in the year
4504 };
4505
4506 // data generated with the following python script:
4507 /*
4508 from DateTime import *
4509 from whrandom import *
4510 from string import *
4511
4512 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
4513 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
4514
4515 def GetMonthWeek(dt):
4516 weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
4517 if weekNumMonth < 0:
4518 weekNumMonth = weekNumMonth + 53
4519 return weekNumMonth
4520
4521 def GetLastSundayBefore(dt):
4522 if dt.iso_week[2] == 7:
4523 return dt
4524 else:
4525 return dt - DateTimeDelta(dt.iso_week[2])
4526
4527 for n in range(20):
4528 year = randint(1900, 2100)
4529 month = randint(1, 12)
4530 day = randint(1, 28)
4531 dt = DateTime(year, month, day)
4532 dayNum = dt.day_of_year
4533 weekNum = dt.iso_week[1]
4534 weekNumMonth = GetMonthWeek(dt)
4535
4536 weekNumMonth2 = 0
4537 dtSunday = GetLastSundayBefore(dt)
4538
4539 while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
4540 weekNumMonth2 = weekNumMonth2 + 1
4541 dtSunday = dtSunday - DateTimeDelta(7)
4542
4543 data = { 'day': rjust(`day`, 2), \
4544 'month': monthNames[month - 1], \
4545 'year': year, \
4546 'weekNum': rjust(`weekNum`, 2), \
4547 'weekNumMonth': weekNumMonth, \
4548 'weekNumMonth2': weekNumMonth2, \
4549 'dayNum': rjust(`dayNum`, 3) }
4550
4551 print " { { %(day)s, "\
4552 "wxDateTime::%(month)s, "\
4553 "%(year)d }, "\
4554 "%(weekNum)s, "\
4555 "%(weekNumMonth)s, "\
4556 "%(weekNumMonth2)s, "\
4557 "%(dayNum)s }," % data
4558
4559 */
4560 static const WeekNumberTestData weekNumberTestDates[] =
4561 {
4562 { { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
4563 { { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
4564 { { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
4565 { { 1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
4566 { { 8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
4567 { { 21, wxDateTime::Mar, 1920 }, 12, 3, 4, 81 },
4568 { { 7, wxDateTime::Jan, 1965 }, 1, 2, 2, 7 },
4569 { { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
4570 { { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
4571 { { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
4572 { { 2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
4573 { { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
4574 { { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
4575 { { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
4576 { { 3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
4577 { { 23, wxDateTime::Feb, 1940 }, 8, 4, 4, 54 },
4578 { { 2, wxDateTime::Jan, 1987 }, 1, 1, 1, 2 },
4579 { { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
4580 { { 2, wxDateTime::Feb, 2063 }, 5, 1, 1, 33 },
4581 { { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
4582 };
4583
4584 for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
4585 {
4586 const WeekNumberTestData& wn = weekNumberTestDates[n];
4587 const Date& d = wn.date;
4588
4589 wxDateTime dt = d.DT();
4590
4591 wxDateTime::wxDateTime_t
4592 week = dt.GetWeekOfYear(wxDateTime::Monday_First),
4593 wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
4594 wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4595 dnum = dt.GetDayOfYear();
4596
4597 wxPrintf(_T("%s: the day number is %d"), d.FormatDate().c_str(), dnum);
4598 if ( dnum == wn.dnum )
4599 {
4600 wxPrintf(_T(" (ok)"));
4601 }
4602 else
4603 {
4604 wxPrintf(_T(" (ERROR: should be %d)"), wn.dnum);
4605 }
4606
4607 wxPrintf(_T(", week in month is %d"), wmon);
4608 if ( wmon == wn.wmon )
4609 {
4610 wxPrintf(_T(" (ok)"));
4611 }
4612 else
4613 {
4614 wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon);
4615 }
4616
4617 wxPrintf(_T(" or %d"), wmon2);
4618 if ( wmon2 == wn.wmon2 )
4619 {
4620 wxPrintf(_T(" (ok)"));
4621 }
4622 else
4623 {
4624 wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon2);
4625 }
4626
4627 wxPrintf(_T(", week in year is %d"), week);
4628 if ( week == wn.week )
4629 {
4630 wxPuts(_T(" (ok)"));
4631 }
4632 else
4633 {
4634 wxPrintf(_T(" (ERROR: should be %d)\n"), wn.week);
4635 }
4636 }
4637 }
4638
4639 // test DST calculations
4640 static void TestTimeDST()
4641 {
4642 wxPuts(_T("\n*** wxDateTime DST test ***"));
4643
4644 wxPrintf(_T("DST is%s in effect now.\n\n"),
4645 wxDateTime::Now().IsDST() ? _T("") : _T(" not"));
4646
4647 // taken from http://www.energy.ca.gov/daylightsaving.html
4648 static const Date datesDST[2][2004 - 1900 + 1] =
4649 {
4650 {
4651 { 1, wxDateTime::Apr, 1990 },
4652 { 7, wxDateTime::Apr, 1991 },
4653 { 5, wxDateTime::Apr, 1992 },
4654 { 4, wxDateTime::Apr, 1993 },
4655 { 3, wxDateTime::Apr, 1994 },
4656 { 2, wxDateTime::Apr, 1995 },
4657 { 7, wxDateTime::Apr, 1996 },
4658 { 6, wxDateTime::Apr, 1997 },
4659 { 5, wxDateTime::Apr, 1998 },
4660 { 4, wxDateTime::Apr, 1999 },
4661 { 2, wxDateTime::Apr, 2000 },
4662 { 1, wxDateTime::Apr, 2001 },
4663 { 7, wxDateTime::Apr, 2002 },
4664 { 6, wxDateTime::Apr, 2003 },
4665 { 4, wxDateTime::Apr, 2004 },
4666 },
4667 {
4668 { 28, wxDateTime::Oct, 1990 },
4669 { 27, wxDateTime::Oct, 1991 },
4670 { 25, wxDateTime::Oct, 1992 },
4671 { 31, wxDateTime::Oct, 1993 },
4672 { 30, wxDateTime::Oct, 1994 },
4673 { 29, wxDateTime::Oct, 1995 },
4674 { 27, wxDateTime::Oct, 1996 },
4675 { 26, wxDateTime::Oct, 1997 },
4676 { 25, wxDateTime::Oct, 1998 },
4677 { 31, wxDateTime::Oct, 1999 },
4678 { 29, wxDateTime::Oct, 2000 },
4679 { 28, wxDateTime::Oct, 2001 },
4680 { 27, wxDateTime::Oct, 2002 },
4681 { 26, wxDateTime::Oct, 2003 },
4682 { 31, wxDateTime::Oct, 2004 },
4683 }
4684 };
4685
4686 int year;
4687 for ( year = 1990; year < 2005; year++ )
4688 {
4689 wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
4690 dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
4691
4692 wxPrintf(_T("DST period in the US for year %d: from %s to %s"),
4693 year, dtBegin.Format().c_str(), dtEnd.Format().c_str());
4694
4695 size_t n = year - 1990;
4696 const Date& dBegin = datesDST[0][n];
4697 const Date& dEnd = datesDST[1][n];
4698
4699 if ( dBegin.SameDay(dtBegin.GetTm()) && dEnd.SameDay(dtEnd.GetTm()) )
4700 {
4701 wxPuts(_T(" (ok)"));
4702 }
4703 else
4704 {
4705 wxPrintf(_T(" (ERROR: should be %s %d to %s %d)\n"),
4706 wxDateTime::GetMonthName(dBegin.month).c_str(), dBegin.day,
4707 wxDateTime::GetMonthName(dEnd.month).c_str(), dEnd.day);
4708 }
4709 }
4710
4711 wxPuts(_T(""));
4712
4713 for ( year = 1990; year < 2005; year++ )
4714 {
4715 wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
4716 year,
4717 wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
4718 wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
4719 }
4720 }
4721
4722 // test wxDateTime -> text conversion
4723 static void TestTimeFormat()
4724 {
4725 wxPuts(_T("\n*** wxDateTime formatting test ***"));
4726
4727 // some information may be lost during conversion, so store what kind
4728 // of info should we recover after a round trip
4729 enum CompareKind
4730 {
4731 CompareNone, // don't try comparing
4732 CompareBoth, // dates and times should be identical
4733 CompareDate, // dates only
4734 CompareTime // time only
4735 };
4736
4737 static const struct
4738 {
4739 CompareKind compareKind;
4740 const wxChar *format;
4741 } formatTestFormats[] =
4742 {
4743 { CompareBoth, _T("---> %c") },
4744 { CompareDate, _T("Date is %A, %d of %B, in year %Y") },
4745 { CompareBoth, _T("Date is %x, time is %X") },
4746 { CompareTime, _T("Time is %H:%M:%S or %I:%M:%S %p") },
4747 { CompareNone, _T("The day of year: %j, the week of year: %W") },
4748 { CompareDate, _T("ISO date without separators: %Y%m%d") },
4749 };
4750
4751 static const Date formatTestDates[] =
4752 {
4753 { 29, wxDateTime::May, 1976, 18, 30, 00 },
4754 { 31, wxDateTime::Dec, 1999, 23, 30, 00 },
4755 #if 0
4756 // this test can't work for other centuries because it uses two digit
4757 // years in formats, so don't even try it
4758 { 29, wxDateTime::May, 2076, 18, 30, 00 },
4759 { 29, wxDateTime::Feb, 2400, 02, 15, 25 },
4760 { 01, wxDateTime::Jan, -52, 03, 16, 47 },
4761 #endif
4762 };
4763
4764 // an extra test (as it doesn't depend on date, don't do it in the loop)
4765 wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
4766
4767 for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
4768 {
4769 wxPuts(_T(""));
4770
4771 wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
4772 for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
4773 {
4774 wxString s = dt.Format(formatTestFormats[n].format);
4775 wxPrintf(_T("%s"), s.c_str());
4776
4777 // what can we recover?
4778 int kind = formatTestFormats[n].compareKind;
4779
4780 // convert back
4781 wxDateTime dt2;
4782 const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
4783 if ( !result )
4784 {
4785 // converion failed - should it have?
4786 if ( kind == CompareNone )
4787 wxPuts(_T(" (ok)"));
4788 else
4789 wxPuts(_T(" (ERROR: conversion back failed)"));
4790 }
4791 else if ( *result )
4792 {
4793 // should have parsed the entire string
4794 wxPuts(_T(" (ERROR: conversion back stopped too soon)"));
4795 }
4796 else
4797 {
4798 bool equal = FALSE; // suppress compilaer warning
4799 switch ( kind )
4800 {
4801 case CompareBoth:
4802 equal = dt2 == dt;
4803 break;
4804
4805 case CompareDate:
4806 equal = dt.IsSameDate(dt2);
4807 break;
4808
4809 case CompareTime:
4810 equal = dt.IsSameTime(dt2);
4811 break;
4812 }
4813
4814 if ( !equal )
4815 {
4816 wxPrintf(_T(" (ERROR: got back '%s' instead of '%s')\n"),
4817 dt2.Format().c_str(), dt.Format().c_str());
4818 }
4819 else
4820 {
4821 wxPuts(_T(" (ok)"));
4822 }
4823 }
4824 }
4825 }
4826 }
4827
4828 // test text -> wxDateTime conversion
4829 static void TestTimeParse()
4830 {
4831 wxPuts(_T("\n*** wxDateTime parse test ***"));
4832
4833 struct ParseTestData
4834 {
4835 const wxChar *format;
4836 Date date;
4837 bool good;
4838 };
4839
4840 static const ParseTestData parseTestDates[] =
4841 {
4842 { _T("Sat, 18 Dec 1999 00:46:40 +0100"), { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, TRUE },
4843 { _T("Wed, 1 Dec 1999 05:17:20 +0300"), { 1, wxDateTime::Dec, 1999, 03, 17, 20 }, TRUE },
4844 };
4845
4846 for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
4847 {
4848 const wxChar *format = parseTestDates[n].format;
4849
4850 wxPrintf(_T("%s => "), format);
4851
4852 wxDateTime dt;
4853 if ( dt.ParseRfc822Date(format) )
4854 {
4855 wxPrintf(_T("%s "), dt.Format().c_str());
4856
4857 if ( parseTestDates[n].good )
4858 {
4859 wxDateTime dtReal = parseTestDates[n].date.DT();
4860 if ( dt == dtReal )
4861 {
4862 wxPuts(_T("(ok)"));
4863 }
4864 else
4865 {
4866 wxPrintf(_T("(ERROR: should be %s)\n"), dtReal.Format().c_str());
4867 }
4868 }
4869 else
4870 {
4871 wxPuts(_T("(ERROR: bad format)"));
4872 }
4873 }
4874 else
4875 {
4876 wxPrintf(_T("bad format (%s)\n"),
4877 parseTestDates[n].good ? "ERROR" : "ok");
4878 }
4879 }
4880 }
4881
4882 static void TestDateTimeInteractive()
4883 {
4884 wxPuts(_T("\n*** interactive wxDateTime tests ***"));
4885
4886 wxChar buf[128];
4887
4888 for ( ;; )
4889 {
4890 wxPrintf(_T("Enter a date: "));
4891 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
4892 break;
4893
4894 // kill the last '\n'
4895 buf[wxStrlen(buf) - 1] = 0;
4896
4897 wxDateTime dt;
4898 const wxChar *p = dt.ParseDate(buf);
4899 if ( !p )
4900 {
4901 wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
4902
4903 continue;
4904 }
4905 else if ( *p )
4906 {
4907 wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
4908 }
4909
4910 wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
4911 dt.Format(_T("%b %d, %Y")).c_str(),
4912 dt.GetDayOfYear(),
4913 dt.GetWeekOfMonth(wxDateTime::Monday_First),
4914 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
4915 dt.GetWeekOfYear(wxDateTime::Monday_First));
4916 }
4917
4918 wxPuts(_T("\n*** done ***"));
4919 }
4920
4921 static void TestTimeMS()
4922 {
4923 wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
4924
4925 wxDateTime dt1 = wxDateTime::Now(),
4926 dt2 = wxDateTime::UNow();
4927
4928 wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
4929 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
4930 wxPrintf(_T("Dummy loop: "));
4931 for ( int i = 0; i < 6000; i++ )
4932 {
4933 //for ( int j = 0; j < 10; j++ )
4934 {
4935 wxString s;
4936 s.Printf(_T("%g"), sqrt(i));
4937 }
4938
4939 if ( !(i % 100) )
4940 putchar('.');
4941 }
4942 wxPuts(_T(", done"));
4943
4944 dt1 = dt2;
4945 dt2 = wxDateTime::UNow();
4946 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
4947
4948 wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
4949
4950 wxPuts(_T("\n*** done ***"));
4951 }
4952
4953 static void TestTimeArithmetics()
4954 {
4955 wxPuts(_T("\n*** testing arithmetic operations on wxDateTime ***"));
4956
4957 static const struct ArithmData
4958 {
4959 ArithmData(const wxDateSpan& sp, const wxChar *nam)
4960 : span(sp), name(nam) { }
4961
4962 wxDateSpan span;
4963 const wxChar *name;
4964 } testArithmData[] =
4965 {
4966 ArithmData(wxDateSpan::Day(), _T("day")),
4967 ArithmData(wxDateSpan::Week(), _T("week")),
4968 ArithmData(wxDateSpan::Month(), _T("month")),
4969 ArithmData(wxDateSpan::Year(), _T("year")),
4970 ArithmData(wxDateSpan(1, 2, 3, 4), _T("year, 2 months, 3 weeks, 4 days")),
4971 };
4972
4973 wxDateTime dt(29, wxDateTime::Dec, 1999), dt1, dt2;
4974
4975 for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
4976 {
4977 wxDateSpan span = testArithmData[n].span;
4978 dt1 = dt + span;
4979 dt2 = dt - span;
4980
4981 const wxChar *name = testArithmData[n].name;
4982 wxPrintf(_T("%s + %s = %s, %s - %s = %s\n"),
4983 dt.FormatISODate().c_str(), name, dt1.FormatISODate().c_str(),
4984 dt.FormatISODate().c_str(), name, dt2.FormatISODate().c_str());
4985
4986 wxPrintf(_T("Going back: %s"), (dt1 - span).FormatISODate().c_str());
4987 if ( dt1 - span == dt )
4988 {
4989 wxPuts(_T(" (ok)"));
4990 }
4991 else
4992 {
4993 wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
4994 }
4995
4996 wxPrintf(_T("Going forward: %s"), (dt2 + span).FormatISODate().c_str());
4997 if ( dt2 + span == dt )
4998 {
4999 wxPuts(_T(" (ok)"));
5000 }
5001 else
5002 {
5003 wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
5004 }
5005
5006 wxPrintf(_T("Double increment: %s"), (dt2 + 2*span).FormatISODate().c_str());
5007 if ( dt2 + 2*span == dt1 )
5008 {
5009 wxPuts(_T(" (ok)"));
5010 }
5011 else
5012 {
5013 wxPrintf(_T(" (ERROR: should be %s)\n"), dt2.FormatISODate().c_str());
5014 }
5015
5016 wxPuts(_T(""));
5017 }
5018 }
5019
5020 static void TestTimeHolidays()
5021 {
5022 wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
5023
5024 wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
5025 wxDateTime dtStart(1, tm.mon, tm.year),
5026 dtEnd = dtStart.GetLastMonthDay();
5027
5028 wxDateTimeArray hol;
5029 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
5030
5031 const wxChar *format = _T("%d-%b-%Y (%a)");
5032
5033 wxPrintf(_T("All holidays between %s and %s:\n"),
5034 dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
5035
5036 size_t count = hol.GetCount();
5037 for ( size_t n = 0; n < count; n++ )
5038 {
5039 wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
5040 }
5041
5042 wxPuts(_T(""));
5043 }
5044
5045 static void TestTimeZoneBug()
5046 {
5047 wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
5048
5049 wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
5050 for ( int i = 0; i < 31; i++ )
5051 {
5052 wxPrintf(_T("Date %s: week day %s.\n"),
5053 date.Format(_T("%d-%m-%Y")).c_str(),
5054 date.GetWeekDayName(date.GetWeekDay()).c_str());
5055
5056 date += wxDateSpan::Day();
5057 }
5058
5059 wxPuts(_T(""));
5060 }
5061
5062 static void TestTimeSpanFormat()
5063 {
5064 wxPuts(_T("\n*** wxTimeSpan tests ***"));
5065
5066 static const wxChar *formats[] =
5067 {
5068 _T("(default) %H:%M:%S"),
5069 _T("%E weeks and %D days"),
5070 _T("%l milliseconds"),
5071 _T("(with ms) %H:%M:%S:%l"),
5072 _T("100%% of minutes is %M"), // test "%%"
5073 _T("%D days and %H hours"),
5074 _T("or also %S seconds"),
5075 };
5076
5077 wxTimeSpan ts1(1, 2, 3, 4),
5078 ts2(111, 222, 333);
5079 for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
5080 {
5081 wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
5082 ts1.Format(formats[n]).c_str(),
5083 ts2.Format(formats[n]).c_str());
5084 }
5085
5086 wxPuts(_T(""));
5087 }
5088
5089 #if 0
5090
5091 // test compatibility with the old wxDate/wxTime classes
5092 static void TestTimeCompatibility()
5093 {
5094 wxPuts(_T("\n*** wxDateTime compatibility test ***"));
5095
5096 wxPrintf(_T("wxDate for JDN 0: %s\n"), wxDate(0l).FormatDate().c_str());
5097 wxPrintf(_T("wxDate for MJD 0: %s\n"), wxDate(2400000).FormatDate().c_str());
5098
5099 double jdnNow = wxDateTime::Now().GetJDN();
5100 long jdnMidnight = (long)(jdnNow - 0.5);
5101 wxPrintf(_T("wxDate for today: %s\n"), wxDate(jdnMidnight).FormatDate().c_str());
5102
5103 jdnMidnight = wxDate().Set().GetJulianDate();
5104 wxPrintf(_T("wxDateTime for today: %s\n"),
5105 wxDateTime((double)(jdnMidnight + 0.5)).Format("%c", wxDateTime::GMT0).c_str());
5106
5107 int flags = wxEUROPEAN;//wxFULL;
5108 wxDate date;
5109 date.Set();
5110 wxPrintf(_T("Today is %s\n"), date.FormatDate(flags).c_str());
5111 for ( int n = 0; n < 7; n++ )
5112 {
5113 wxPrintf(_T("Previous %s is %s\n"),
5114 wxDateTime::GetWeekDayName((wxDateTime::WeekDay)n),
5115 date.Previous(n + 1).FormatDate(flags).c_str());
5116 }
5117 }
5118
5119 #endif // 0
5120
5121 #endif // TEST_DATETIME
5122
5123 // ----------------------------------------------------------------------------
5124 // threads
5125 // ----------------------------------------------------------------------------
5126
5127 #ifdef TEST_THREADS
5128
5129 #include "wx/thread.h"
5130
5131 static size_t gs_counter = (size_t)-1;
5132 static wxCriticalSection gs_critsect;
5133 static wxSemaphore gs_cond;
5134
5135 class MyJoinableThread : public wxThread
5136 {
5137 public:
5138 MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
5139 { m_n = n; Create(); }
5140
5141 // thread execution starts here
5142 virtual ExitCode Entry();
5143
5144 private:
5145 size_t m_n;
5146 };
5147
5148 wxThread::ExitCode MyJoinableThread::Entry()
5149 {
5150 unsigned long res = 1;
5151 for ( size_t n = 1; n < m_n; n++ )
5152 {
5153 res *= n;
5154
5155 // it's a loooong calculation :-)
5156 Sleep(100);
5157 }
5158
5159 return (ExitCode)res;
5160 }
5161
5162 class MyDetachedThread : public wxThread
5163 {
5164 public:
5165 MyDetachedThread(size_t n, wxChar ch)
5166 {
5167 m_n = n;
5168 m_ch = ch;
5169 m_cancelled = FALSE;
5170
5171 Create();
5172 }
5173
5174 // thread execution starts here
5175 virtual ExitCode Entry();
5176
5177 // and stops here
5178 virtual void OnExit();
5179
5180 private:
5181 size_t m_n; // number of characters to write
5182 wxChar m_ch; // character to write
5183
5184 bool m_cancelled; // FALSE if we exit normally
5185 };
5186
5187 wxThread::ExitCode MyDetachedThread::Entry()
5188 {
5189 {
5190 wxCriticalSectionLocker lock(gs_critsect);
5191 if ( gs_counter == (size_t)-1 )
5192 gs_counter = 1;
5193 else
5194 gs_counter++;
5195 }
5196
5197 for ( size_t n = 0; n < m_n; n++ )
5198 {
5199 if ( TestDestroy() )
5200 {
5201 m_cancelled = TRUE;
5202
5203 break;
5204 }
5205
5206 putchar(m_ch);
5207 fflush(stdout);
5208
5209 wxThread::Sleep(100);
5210 }
5211
5212 return 0;
5213 }
5214
5215 void MyDetachedThread::OnExit()
5216 {
5217 wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
5218
5219 wxCriticalSectionLocker lock(gs_critsect);
5220 if ( !--gs_counter && !m_cancelled )
5221 gs_cond.Post();
5222 }
5223
5224 static void TestDetachedThreads()
5225 {
5226 wxPuts(_T("\n*** Testing detached threads ***"));
5227
5228 static const size_t nThreads = 3;
5229 MyDetachedThread *threads[nThreads];
5230 size_t n;
5231 for ( n = 0; n < nThreads; n++ )
5232 {
5233 threads[n] = new MyDetachedThread(10, 'A' + n);
5234 }
5235
5236 threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
5237 threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
5238
5239 for ( n = 0; n < nThreads; n++ )
5240 {
5241 threads[n]->Run();
5242 }
5243
5244 // wait until all threads terminate
5245 gs_cond.Wait();
5246
5247 wxPuts(_T(""));
5248 }
5249
5250 static void TestJoinableThreads()
5251 {
5252 wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
5253
5254 // calc 10! in the background
5255 MyJoinableThread thread(10);
5256 thread.Run();
5257
5258 wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
5259 (unsigned long)thread.Wait());
5260 }
5261
5262 static void TestThreadSuspend()
5263 {
5264 wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
5265
5266 MyDetachedThread *thread = new MyDetachedThread(15, 'X');
5267
5268 thread->Run();
5269
5270 // this is for this demo only, in a real life program we'd use another
5271 // condition variable which would be signaled from wxThread::Entry() to
5272 // tell us that the thread really started running - but here just wait a
5273 // bit and hope that it will be enough (the problem is, of course, that
5274 // the thread might still not run when we call Pause() which will result
5275 // in an error)
5276 wxThread::Sleep(300);
5277
5278 for ( size_t n = 0; n < 3; n++ )
5279 {
5280 thread->Pause();
5281
5282 wxPuts(_T("\nThread suspended"));
5283 if ( n > 0 )
5284 {
5285 // don't sleep but resume immediately the first time
5286 wxThread::Sleep(300);
5287 }
5288 wxPuts(_T("Going to resume the thread"));
5289
5290 thread->Resume();
5291 }
5292
5293 wxPuts(_T("Waiting until it terminates now"));
5294
5295 // wait until the thread terminates
5296 gs_cond.Wait();
5297
5298 wxPuts(_T(""));
5299 }
5300
5301 static void TestThreadDelete()
5302 {
5303 // As above, using Sleep() is only for testing here - we must use some
5304 // synchronisation object instead to ensure that the thread is still
5305 // running when we delete it - deleting a detached thread which already
5306 // terminated will lead to a crash!
5307
5308 wxPuts(_T("\n*** Testing thread delete function ***"));
5309
5310 MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
5311
5312 thread0->Delete();
5313
5314 wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
5315
5316 MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
5317
5318 thread1->Run();
5319
5320 wxThread::Sleep(300);
5321
5322 thread1->Delete();
5323
5324 wxPuts(_T("\nDeleted a running thread."));
5325
5326 MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
5327
5328 thread2->Run();
5329
5330 wxThread::Sleep(300);
5331
5332 thread2->Pause();
5333
5334 thread2->Delete();
5335
5336 wxPuts(_T("\nDeleted a sleeping thread."));
5337
5338 MyJoinableThread thread3(20);
5339 thread3.Run();
5340
5341 thread3.Delete();
5342
5343 wxPuts(_T("\nDeleted a joinable thread."));
5344
5345 MyJoinableThread thread4(2);
5346 thread4.Run();
5347
5348 wxThread::Sleep(300);
5349
5350 thread4.Delete();
5351
5352 wxPuts(_T("\nDeleted a joinable thread which already terminated."));
5353
5354 wxPuts(_T(""));
5355 }
5356
5357 class MyWaitingThread : public wxThread
5358 {
5359 public:
5360 MyWaitingThread( wxMutex *mutex, wxCondition *condition )
5361 {
5362 m_mutex = mutex;
5363 m_condition = condition;
5364
5365 Create();
5366 }
5367
5368 virtual ExitCode Entry()
5369 {
5370 wxPrintf(_T("Thread %lu has started running.\n"), GetId());
5371 fflush(stdout);
5372
5373 gs_cond.Post();
5374
5375 wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
5376 fflush(stdout);
5377
5378 m_mutex->Lock();
5379 m_condition->Wait();
5380 m_mutex->Unlock();
5381
5382 wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
5383 fflush(stdout);
5384
5385 return 0;
5386 }
5387
5388 private:
5389 wxMutex *m_mutex;
5390 wxCondition *m_condition;
5391 };
5392
5393 static void TestThreadConditions()
5394 {
5395 wxMutex mutex;
5396 wxCondition condition(mutex);
5397
5398 // otherwise its difficult to understand which log messages pertain to
5399 // which condition
5400 //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
5401 // condition.GetId(), gs_cond.GetId());
5402
5403 // create and launch threads
5404 MyWaitingThread *threads[10];
5405
5406 size_t n;
5407 for ( n = 0; n < WXSIZEOF(threads); n++ )
5408 {
5409 threads[n] = new MyWaitingThread( &mutex, &condition );
5410 }
5411
5412 for ( n = 0; n < WXSIZEOF(threads); n++ )
5413 {
5414 threads[n]->Run();
5415 }
5416
5417 // wait until all threads run
5418 wxPuts(_T("Main thread is waiting for the other threads to start"));
5419 fflush(stdout);
5420
5421 size_t nRunning = 0;
5422 while ( nRunning < WXSIZEOF(threads) )
5423 {
5424 gs_cond.Wait();
5425
5426 nRunning++;
5427
5428 wxPrintf(_T("Main thread: %u already running\n"), nRunning);
5429 fflush(stdout);
5430 }
5431
5432 wxPuts(_T("Main thread: all threads started up."));
5433 fflush(stdout);
5434
5435 wxThread::Sleep(500);
5436
5437 #if 1
5438 // now wake one of them up
5439 wxPrintf(_T("Main thread: about to signal the condition.\n"));
5440 fflush(stdout);
5441 condition.Signal();
5442 #endif
5443
5444 wxThread::Sleep(200);
5445
5446 // wake all the (remaining) threads up, so that they can exit
5447 wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
5448 fflush(stdout);
5449 condition.Broadcast();
5450
5451 // give them time to terminate (dirty!)
5452 wxThread::Sleep(500);
5453 }
5454
5455 #include "wx/utils.h"
5456
5457 class MyExecThread : public wxThread
5458 {
5459 public:
5460 MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
5461 m_command(command)
5462 {
5463 Create();
5464 }
5465
5466 virtual ExitCode Entry()
5467 {
5468 return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
5469 }
5470
5471 private:
5472 wxString m_command;
5473 };
5474
5475 static void TestThreadExec()
5476 {
5477 wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
5478
5479 MyExecThread thread(_T("true"));
5480 thread.Run();
5481
5482 wxPrintf(_T("Main program exit code: %ld.\n"),
5483 wxExecute(_T("false"), wxEXEC_SYNC));
5484
5485 wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
5486 }
5487
5488 // semaphore tests
5489 #include "wx/datetime.h"
5490
5491 class MySemaphoreThread : public wxThread
5492 {
5493 public:
5494 MySemaphoreThread(int i, wxSemaphore *sem)
5495 : wxThread(wxTHREAD_JOINABLE),
5496 m_sem(sem),
5497 m_i(i)
5498 {
5499 Create();
5500 }
5501
5502 virtual ExitCode Entry()
5503 {
5504 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
5505 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5506
5507 m_sem->Wait();
5508
5509 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
5510 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5511
5512 Sleep(1000);
5513
5514 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
5515 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
5516
5517 m_sem->Post();
5518
5519 return 0;
5520 }
5521
5522 private:
5523 wxSemaphore *m_sem;
5524 int m_i;
5525 };
5526
5527 WX_DEFINE_ARRAY(wxThread *, ArrayThreads);
5528
5529 static void TestSemaphore()
5530 {
5531 wxPuts(_T("*** Testing wxSemaphore class. ***"));
5532
5533 static const int SEM_LIMIT = 3;
5534
5535 wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
5536 ArrayThreads threads;
5537
5538 for ( int i = 0; i < 3*SEM_LIMIT; i++ )
5539 {
5540 threads.Add(new MySemaphoreThread(i, &sem));
5541 threads.Last()->Run();
5542 }
5543
5544 for ( size_t n = 0; n < threads.GetCount(); n++ )
5545 {
5546 threads[n]->Wait();
5547 delete threads[n];
5548 }
5549 }
5550
5551 #endif // TEST_THREADS
5552
5553 // ----------------------------------------------------------------------------
5554 // arrays
5555 // ----------------------------------------------------------------------------
5556
5557 #ifdef TEST_ARRAYS
5558
5559 #include "wx/dynarray.h"
5560
5561 typedef unsigned short ushort;
5562
5563 #define DefineCompare(name, T) \
5564 \
5565 int wxCMPFUNC_CONV name ## CompareValues(T first, T second) \
5566 { \
5567 return first - second; \
5568 } \
5569 \
5570 int wxCMPFUNC_CONV name ## Compare(T* first, T* second) \
5571 { \
5572 return *first - *second; \
5573 } \
5574 \
5575 int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second) \
5576 { \
5577 return *second - *first; \
5578 } \
5579
5580 DefineCompare(UShort, ushort);
5581 DefineCompare(Int, int);
5582
5583 // test compilation of all macros
5584 WX_DEFINE_ARRAY_SHORT(ushort, wxArrayUShort);
5585 WX_DEFINE_SORTED_ARRAY_SHORT(ushort, wxSortedArrayUShortNoCmp);
5586 WX_DEFINE_SORTED_ARRAY_CMP_SHORT(ushort, UShortCompareValues, wxSortedArrayUShort);
5587 WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt);
5588
5589 WX_DECLARE_OBJARRAY(Bar, ArrayBars);
5590 #include "wx/arrimpl.cpp"
5591 WX_DEFINE_OBJARRAY(ArrayBars);
5592
5593 static void PrintArray(const wxChar* name, const wxArrayString& array)
5594 {
5595 wxPrintf(_T("Dump of the array '%s'\n"), name);
5596
5597 size_t nCount = array.GetCount();
5598 for ( size_t n = 0; n < nCount; n++ )
5599 {
5600 wxPrintf(_T("\t%s[%u] = '%s'\n"), name, n, array[n].c_str());
5601 }
5602 }
5603
5604 int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
5605 const wxString& second)
5606 {
5607 return first.length() - second.length();
5608 }
5609
5610 #define TestArrayOf(name) \
5611 \
5612 static void PrintArray(const wxChar* name, const wxSortedArray##name & array) \
5613 { \
5614 wxPrintf(_T("Dump of the array '%s'\n"), name); \
5615 \
5616 size_t nCount = array.GetCount(); \
5617 for ( size_t n = 0; n < nCount; n++ ) \
5618 { \
5619 wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]); \
5620 } \
5621 } \
5622 \
5623 static void PrintArray(const wxChar* name, const wxArray##name & array) \
5624 { \
5625 wxPrintf(_T("Dump of the array '%s'\n"), name); \
5626 \
5627 size_t nCount = array.GetCount(); \
5628 for ( size_t n = 0; n < nCount; n++ ) \
5629 { \
5630 wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]); \
5631 } \
5632 } \
5633 \
5634 static void TestArrayOf ## name ## s() \
5635 { \
5636 wxPrintf(_T("*** Testing wxArray%s ***\n"), #name); \
5637 \
5638 wxArray##name a; \
5639 a.Add(1); \
5640 a.Add(17,2); \
5641 a.Add(5,3); \
5642 a.Add(3,4); \
5643 \
5644 wxPuts(_T("Initially:")); \
5645 PrintArray(_T("a"), a); \
5646 \
5647 wxPuts(_T("After sort:")); \
5648 a.Sort(name ## Compare); \
5649 PrintArray(_T("a"), a); \
5650 \
5651 wxPuts(_T("After reverse sort:")); \
5652 a.Sort(name ## RevCompare); \
5653 PrintArray(_T("a"), a); \
5654 \
5655 wxSortedArray##name b; \
5656 b.Add(1); \
5657 b.Add(17); \
5658 b.Add(5); \
5659 b.Add(3); \
5660 \
5661 wxPuts(_T("Sorted array initially:")); \
5662 PrintArray(_T("b"), b); \
5663 }
5664
5665 TestArrayOf(UShort);
5666 TestArrayOf(Int);
5667
5668 static void TestArrayOfObjects()
5669 {
5670 wxPuts(_T("*** Testing wxObjArray ***\n"));
5671
5672 {
5673 ArrayBars bars;
5674 Bar bar("second bar (two copies!)");
5675
5676 wxPrintf(_T("Initially: %u objects in the array, %u objects total.\n"),
5677 bars.GetCount(), Bar::GetNumber());
5678
5679 bars.Add(new Bar("first bar"));
5680 bars.Add(bar,2);
5681
5682 wxPrintf(_T("Now: %u objects in the array, %u objects total.\n"),
5683 bars.GetCount(), Bar::GetNumber());
5684
5685 bars.RemoveAt(1, bars.GetCount() - 1);
5686
5687 wxPrintf(_T("After removing all but first element: %u objects in the ")
5688 _T("array, %u objects total.\n"),
5689 bars.GetCount(), Bar::GetNumber());
5690
5691 bars.Empty();
5692
5693 wxPrintf(_T("After Empty(): %u objects in the array, %u objects total.\n"),
5694 bars.GetCount(), Bar::GetNumber());
5695 }
5696
5697 wxPrintf(_T("Finally: no more objects in the array, %u objects total.\n"),
5698 Bar::GetNumber());
5699 }
5700
5701 #endif // TEST_ARRAYS
5702
5703 // ----------------------------------------------------------------------------
5704 // strings
5705 // ----------------------------------------------------------------------------
5706
5707 #ifdef TEST_STRINGS
5708
5709 #include "wx/timer.h"
5710 #include "wx/tokenzr.h"
5711
5712 static void TestStringConstruction()
5713 {
5714 wxPuts(_T("*** Testing wxString constructores ***"));
5715
5716 #define TEST_CTOR(args, res) \
5717 { \
5718 wxString s args ; \
5719 wxPrintf(_T("wxString%s = %s "), #args, s.c_str()); \
5720 if ( s == res ) \
5721 { \
5722 wxPuts(_T("(ok)")); \
5723 } \
5724 else \
5725 { \
5726 wxPrintf(_T("(ERROR: should be %s)\n"), res); \
5727 } \
5728 }
5729
5730 TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
5731 TEST_CTOR((_T("Hello"), 4), _T("Hell"));
5732 TEST_CTOR((_T("Hello"), 5), _T("Hello"));
5733 // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
5734
5735 static const wxChar *s = _T("?really!");
5736 const wxChar *start = wxStrchr(s, _T('r'));
5737 const wxChar *end = wxStrchr(s, _T('!'));
5738 TEST_CTOR((start, end), _T("really"));
5739
5740 wxPuts(_T(""));
5741 }
5742
5743 static void TestString()
5744 {
5745 wxStopWatch sw;
5746
5747 wxString a, b, c;
5748
5749 a.reserve (128);
5750 b.reserve (128);
5751 c.reserve (128);
5752
5753 for (int i = 0; i < 1000000; ++i)
5754 {
5755 a = "Hello";
5756 b = " world";
5757 c = "! How'ya doin'?";
5758 a += b;
5759 a += c;
5760 c = "Hello world! What's up?";
5761 if (c != a)
5762 c = "Doh!";
5763 }
5764
5765 wxPrintf(_T("TestString elapsed time: %ld\n"), sw.Time());
5766 }
5767
5768 static void TestPChar()
5769 {
5770 wxStopWatch sw;
5771
5772 wxChar a [128];
5773 wxChar b [128];
5774 wxChar c [128];
5775
5776 for (int i = 0; i < 1000000; ++i)
5777 {
5778 wxStrcpy (a, _T("Hello"));
5779 wxStrcpy (b, _T(" world"));
5780 wxStrcpy (c, _T("! How'ya doin'?"));
5781 wxStrcat (a, b);
5782 wxStrcat (a, c);
5783 wxStrcpy (c, _T("Hello world! What's up?"));
5784 if (wxStrcmp (c, a) == 0)
5785 wxStrcpy (c, _T("Doh!"));
5786 }
5787
5788 wxPrintf(_T("TestPChar elapsed time: %ld\n"), sw.Time());
5789 }
5790
5791 static void TestStringSub()
5792 {
5793 wxString s("Hello, world!");
5794
5795 wxPuts(_T("*** Testing wxString substring extraction ***"));
5796
5797 wxPrintf(_T("String = '%s'\n"), s.c_str());
5798 wxPrintf(_T("Left(5) = '%s'\n"), s.Left(5).c_str());
5799 wxPrintf(_T("Right(6) = '%s'\n"), s.Right(6).c_str());
5800 wxPrintf(_T("Mid(3, 5) = '%s'\n"), s(3, 5).c_str());
5801 wxPrintf(_T("Mid(3) = '%s'\n"), s.Mid(3).c_str());
5802 wxPrintf(_T("substr(3, 5) = '%s'\n"), s.substr(3, 5).c_str());
5803 wxPrintf(_T("substr(3) = '%s'\n"), s.substr(3).c_str());
5804
5805 static const wxChar *prefixes[] =
5806 {
5807 _T("Hello"),
5808 _T("Hello, "),
5809 _T("Hello, world!"),
5810 _T("Hello, world!!!"),
5811 _T(""),
5812 _T("Goodbye"),
5813 _T("Hi"),
5814 };
5815
5816 for ( size_t n = 0; n < WXSIZEOF(prefixes); n++ )
5817 {
5818 wxString prefix = prefixes[n], rest;
5819 bool rc = s.StartsWith(prefix, &rest);
5820 wxPrintf(_T("StartsWith('%s') = %s"), prefix.c_str(), rc ? _T("TRUE") : _T("FALSE"));
5821 if ( rc )
5822 {
5823 wxPrintf(_T(" (the rest is '%s')\n"), rest.c_str());
5824 }
5825 else
5826 {
5827 putchar('\n');
5828 }
5829 }
5830
5831 wxPuts(_T(""));
5832 }
5833
5834 static void TestStringFormat()
5835 {
5836 wxPuts(_T("*** Testing wxString formatting ***"));
5837
5838 wxString s;
5839 s.Printf(_T("%03d"), 18);
5840
5841 wxPrintf(_T("Number 18: %s\n"), wxString::Format(_T("%03d"), 18).c_str());
5842 wxPrintf(_T("Number 18: %s\n"), s.c_str());
5843
5844 wxPuts(_T(""));
5845 }
5846
5847 // returns "not found" for npos, value for all others
5848 static wxString PosToString(size_t res)
5849 {
5850 wxString s = res == wxString::npos ? wxString(_T("not found"))
5851 : wxString::Format(_T("%u"), res);
5852 return s;
5853 }
5854
5855 static void TestStringFind()
5856 {
5857 wxPuts(_T("*** Testing wxString find() functions ***"));
5858
5859 static const wxChar *strToFind = _T("ell");
5860 static const struct StringFindTest
5861 {
5862 const wxChar *str;
5863 size_t start,
5864 result; // of searching "ell" in str
5865 } findTestData[] =
5866 {
5867 { _T("Well, hello world"), 0, 1 },
5868 { _T("Well, hello world"), 6, 7 },
5869 { _T("Well, hello world"), 9, wxString::npos },
5870 };
5871
5872 for ( size_t n = 0; n < WXSIZEOF(findTestData); n++ )
5873 {
5874 const StringFindTest& ft = findTestData[n];
5875 size_t res = wxString(ft.str).find(strToFind, ft.start);
5876
5877 wxPrintf(_T("Index of '%s' in '%s' starting from %u is %s "),
5878 strToFind, ft.str, ft.start, PosToString(res).c_str());
5879
5880 size_t resTrue = ft.result;
5881 if ( res == resTrue )
5882 {
5883 wxPuts(_T("(ok)"));
5884 }
5885 else
5886 {
5887 wxPrintf(_T("(ERROR: should be %s)\n"),
5888 PosToString(resTrue).c_str());
5889 }
5890 }
5891
5892 wxPuts(_T(""));
5893 }
5894
5895 static void TestStringTokenizer()
5896 {
5897 wxPuts(_T("*** Testing wxStringTokenizer ***"));
5898
5899 static const wxChar *modeNames[] =
5900 {
5901 _T("default"),
5902 _T("return empty"),
5903 _T("return all empty"),
5904 _T("with delims"),
5905 _T("like strtok"),
5906 };
5907
5908 static const struct StringTokenizerTest
5909 {
5910 const wxChar *str; // string to tokenize
5911 const wxChar *delims; // delimiters to use
5912 size_t count; // count of token
5913 wxStringTokenizerMode mode; // how should we tokenize it
5914 } tokenizerTestData[] =
5915 {
5916 { _T(""), _T(" "), 0 },
5917 { _T("Hello, world"), _T(" "), 2 },
5918 { _T("Hello, world "), _T(" "), 2 },
5919 { _T("Hello, world"), _T(","), 2 },
5920 { _T("Hello, world!"), _T(",!"), 2 },
5921 { _T("Hello,, world!"), _T(",!"), 3 },
5922 { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL },
5923 { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
5924 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 4 },
5925 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY },
5926 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL },
5927 { _T("01/02/99"), _T("/-"), 3 },
5928 { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS },
5929 };
5930
5931 for ( size_t n = 0; n < WXSIZEOF(tokenizerTestData); n++ )
5932 {
5933 const StringTokenizerTest& tt = tokenizerTestData[n];
5934 wxStringTokenizer tkz(tt.str, tt.delims, tt.mode);
5935
5936 size_t count = tkz.CountTokens();
5937 wxPrintf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
5938 MakePrintable(tt.str).c_str(),
5939 count,
5940 MakePrintable(tt.delims).c_str(),
5941 modeNames[tkz.GetMode()]);
5942 if ( count == tt.count )
5943 {
5944 wxPuts(_T("(ok)"));
5945 }
5946 else
5947 {
5948 wxPrintf(_T("(ERROR: should be %u)\n"), tt.count);
5949
5950 continue;
5951 }
5952
5953 // if we emulate strtok(), check that we do it correctly
5954 wxChar *buf, *s = NULL, *last;
5955
5956 if ( tkz.GetMode() == wxTOKEN_STRTOK )
5957 {
5958 buf = new wxChar[wxStrlen(tt.str) + 1];
5959 wxStrcpy(buf, tt.str);
5960
5961 s = wxStrtok(buf, tt.delims, &last);
5962 }
5963 else
5964 {
5965 buf = NULL;
5966 }
5967
5968 // now show the tokens themselves
5969 size_t count2 = 0;
5970 while ( tkz.HasMoreTokens() )
5971 {
5972 wxString token = tkz.GetNextToken();
5973
5974 wxPrintf(_T("\ttoken %u: '%s'"),
5975 ++count2,
5976 MakePrintable(token).c_str());
5977
5978 if ( buf )
5979 {
5980 if ( token == s )
5981 {
5982 wxPuts(_T(" (ok)"));
5983 }
5984 else
5985 {
5986 wxPrintf(_T(" (ERROR: should be %s)\n"), s);
5987 }
5988
5989 s = wxStrtok(NULL, tt.delims, &last);
5990 }
5991 else
5992 {
5993 // nothing to compare with
5994 wxPuts(_T(""));
5995 }
5996 }
5997
5998 if ( count2 != count )
5999 {
6000 wxPuts(_T("\tERROR: token count mismatch"));
6001 }
6002
6003 delete [] buf;
6004 }
6005
6006 wxPuts(_T(""));
6007 }
6008
6009 static void TestStringReplace()
6010 {
6011 wxPuts(_T("*** Testing wxString::replace ***"));
6012
6013 static const struct StringReplaceTestData
6014 {
6015 const wxChar *original; // original test string
6016 size_t start, len; // the part to replace
6017 const wxChar *replacement; // the replacement string
6018 const wxChar *result; // and the expected result
6019 } stringReplaceTestData[] =
6020 {
6021 { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
6022 { _T("increase"), 0, 2, _T("de"), _T("decrease") },
6023 { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
6024 { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
6025 { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
6026 };
6027
6028 for ( size_t n = 0; n < WXSIZEOF(stringReplaceTestData); n++ )
6029 {
6030 const StringReplaceTestData data = stringReplaceTestData[n];
6031
6032 wxString original = data.original;
6033 original.replace(data.start, data.len, data.replacement);
6034
6035 wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
6036 data.original, data.start, data.len, data.replacement,
6037 original.c_str());
6038
6039 if ( original == data.result )
6040 {
6041 wxPuts(_T("(ok)"));
6042 }
6043 else
6044 {
6045 wxPrintf(_T("(ERROR: should be '%s')\n"), data.result);
6046 }
6047 }
6048
6049 wxPuts(_T(""));
6050 }
6051
6052 static void TestStringMatch()
6053 {
6054 wxPuts(_T("*** Testing wxString::Matches() ***"));
6055
6056 static const struct StringMatchTestData
6057 {
6058 const wxChar *text;
6059 const wxChar *wildcard;
6060 bool matches;
6061 } stringMatchTestData[] =
6062 {
6063 { _T("foobar"), _T("foo*"), 1 },
6064 { _T("foobar"), _T("*oo*"), 1 },
6065 { _T("foobar"), _T("*bar"), 1 },
6066 { _T("foobar"), _T("??????"), 1 },
6067 { _T("foobar"), _T("f??b*"), 1 },
6068 { _T("foobar"), _T("f?b*"), 0 },
6069 { _T("foobar"), _T("*goo*"), 0 },
6070 { _T("foobar"), _T("*foo"), 0 },
6071 { _T("foobarfoo"), _T("*foo"), 1 },
6072 { _T(""), _T("*"), 1 },
6073 { _T(""), _T("?"), 0 },
6074 };
6075
6076 for ( size_t n = 0; n < WXSIZEOF(stringMatchTestData); n++ )
6077 {
6078 const StringMatchTestData& data = stringMatchTestData[n];
6079 bool matches = wxString(data.text).Matches(data.wildcard);
6080 wxPrintf(_T("'%s' %s '%s' (%s)\n"),
6081 data.wildcard,
6082 matches ? _T("matches") : _T("doesn't match"),
6083 data.text,
6084 matches == data.matches ? _T("ok") : _T("ERROR"));
6085 }
6086
6087 wxPuts(_T(""));
6088 }
6089
6090 #endif // TEST_STRINGS
6091
6092 // ----------------------------------------------------------------------------
6093 // entry point
6094 // ----------------------------------------------------------------------------
6095
6096 #ifdef TEST_SNGLINST
6097 #include "wx/snglinst.h"
6098 #endif // TEST_SNGLINST
6099
6100 int main(int argc, char **argv)
6101 {
6102 wxApp::CheckBuildOptions(wxBuildOptions());
6103
6104 wxInitializer initializer;
6105 if ( !initializer )
6106 {
6107 fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
6108
6109 return -1;
6110 }
6111
6112 #ifdef TEST_SNGLINST
6113 wxSingleInstanceChecker checker;
6114 if ( checker.Create(_T(".wxconsole.lock")) )
6115 {
6116 if ( checker.IsAnotherRunning() )
6117 {
6118 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
6119
6120 return 1;
6121 }
6122
6123 // wait some time to give time to launch another instance
6124 wxPrintf(_T("Press \"Enter\" to continue..."));
6125 wxFgetc(stdin);
6126 }
6127 else // failed to create
6128 {
6129 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
6130 }
6131 #endif // TEST_SNGLINST
6132
6133 #ifdef TEST_CHARSET
6134 TestCharset();
6135 #endif // TEST_CHARSET
6136
6137 #ifdef TEST_CMDLINE
6138 TestCmdLineConvert();
6139
6140 #if wxUSE_CMDLINE_PARSER
6141 static const wxCmdLineEntryDesc cmdLineDesc[] =
6142 {
6143 { wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
6144 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
6145 { wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
6146 { wxCMD_LINE_SWITCH, _T("q"), _T("quiet"), _T("be quiet") },
6147
6148 { wxCMD_LINE_OPTION, _T("o"), _T("output"), _T("output file") },
6149 { wxCMD_LINE_OPTION, _T("i"), _T("input"), _T("input dir") },
6150 { wxCMD_LINE_OPTION, _T("s"), _T("size"), _T("output block size"),
6151 wxCMD_LINE_VAL_NUMBER },
6152 { wxCMD_LINE_OPTION, _T("d"), _T("date"), _T("output file date"),
6153 wxCMD_LINE_VAL_DATE },
6154
6155 { wxCMD_LINE_PARAM, NULL, NULL, _T("input file"),
6156 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
6157
6158 { wxCMD_LINE_NONE }
6159 };
6160
6161 #if wxUSE_UNICODE
6162 wxChar **wargv = new wxChar *[argc + 1];
6163
6164 {
6165 for ( int n = 0; n < argc; n++ )
6166 {
6167 wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
6168 wargv[n] = wxStrdup(warg);
6169 }
6170
6171 wargv[n] = NULL;
6172 }
6173
6174 #define argv wargv
6175 #endif // wxUSE_UNICODE
6176
6177 wxCmdLineParser parser(cmdLineDesc, argc, argv);
6178
6179 #if wxUSE_UNICODE
6180 {
6181 for ( int n = 0; n < argc; n++ )
6182 free(wargv[n]);
6183
6184 delete [] wargv;
6185 }
6186 #endif // wxUSE_UNICODE
6187
6188 parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
6189 wxCMD_LINE_VAL_STRING,
6190 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
6191
6192 switch ( parser.Parse() )
6193 {
6194 case -1:
6195 wxLogMessage(_T("Help was given, terminating."));
6196 break;
6197
6198 case 0:
6199 ShowCmdLine(parser);
6200 break;
6201
6202 default:
6203 wxLogMessage(_T("Syntax error detected, aborting."));
6204 break;
6205 }
6206 #endif // wxUSE_CMDLINE_PARSER
6207
6208 #endif // TEST_CMDLINE
6209
6210 #ifdef TEST_STRINGS
6211 if ( TEST_ALL )
6212 {
6213 TestPChar();
6214 TestString();
6215 TestStringSub();
6216 TestStringConstruction();
6217 TestStringFormat();
6218 TestStringFind();
6219 TestStringTokenizer();
6220 TestStringReplace();
6221 }
6222 else
6223 {
6224 TestStringMatch();
6225 }
6226 #endif // TEST_STRINGS
6227
6228 #ifdef TEST_ARRAYS
6229 if ( TEST_ALL )
6230 {
6231 wxArrayString a1;
6232 a1.Add(_T("tiger"));
6233 a1.Add(_T("cat"));
6234 a1.Add(_T("lion"), 3);
6235 a1.Add(_T("dog"));
6236 a1.Add(_T("human"));
6237 a1.Add(_T("ape"));
6238
6239 wxPuts(_T("*** Initially:"));
6240
6241 PrintArray(_T("a1"), a1);
6242
6243 wxArrayString a2(a1);
6244 PrintArray(_T("a2"), a2);
6245
6246 wxSortedArrayString a3(a1);
6247 PrintArray(_T("a3"), a3);
6248
6249 wxPuts(_T("*** After deleting three strings from a1"));
6250 a1.Remove(2,3);
6251
6252 PrintArray(_T("a1"), a1);
6253 PrintArray(_T("a2"), a2);
6254 PrintArray(_T("a3"), a3);
6255
6256 wxPuts(_T("*** After reassigning a1 to a2 and a3"));
6257 a3 = a2 = a1;
6258 PrintArray(_T("a2"), a2);
6259 PrintArray(_T("a3"), a3);
6260
6261 wxPuts(_T("*** After sorting a1"));
6262 a1.Sort();
6263 PrintArray(_T("a1"), a1);
6264
6265 wxPuts(_T("*** After sorting a1 in reverse order"));
6266 a1.Sort(TRUE);
6267 PrintArray(_T("a1"), a1);
6268
6269 wxPuts(_T("*** After sorting a1 by the string length"));
6270 a1.Sort(StringLenCompare);
6271 PrintArray(_T("a1"), a1);
6272
6273 TestArrayOfObjects();
6274 TestArrayOfUShorts();
6275 }
6276
6277 TestArrayOfInts();
6278 #endif // TEST_ARRAYS
6279
6280 #ifdef TEST_DIR
6281 if ( TEST_ALL )
6282 {
6283 TestDirExists();
6284 TestDirTraverse();
6285 }
6286 TestDirEnum();
6287 #endif // TEST_DIR
6288
6289 #ifdef TEST_DLLLOADER
6290 TestDllLoad();
6291 #endif // TEST_DLLLOADER
6292
6293 #ifdef TEST_ENVIRON
6294 TestEnvironment();
6295 #endif // TEST_ENVIRON
6296
6297 #ifdef TEST_EXECUTE
6298 TestExecute();
6299 #endif // TEST_EXECUTE
6300
6301 #ifdef TEST_FILECONF
6302 TestFileConfRead();
6303 #endif // TEST_FILECONF
6304
6305 #ifdef TEST_LIST
6306 TestListCtor();
6307 #endif // TEST_LIST
6308
6309 #ifdef TEST_LOCALE
6310 TestDefaultLang();
6311 #endif // TEST_LOCALE
6312
6313 #ifdef TEST_LOG
6314 wxString s;
6315 for ( size_t n = 0; n < 8000; n++ )
6316 {
6317 s << (wxChar)(_T('A') + (n % 26));
6318 }
6319
6320 wxString msg;
6321 msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
6322
6323 // this one shouldn't be truncated
6324 wxPrintf(msg);
6325
6326 // but this one will because log functions use fixed size buffer
6327 // (note that it doesn't need '\n' at the end neither - will be added
6328 // by wxLog anyhow)
6329 wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
6330 #endif // TEST_LOG
6331
6332 #ifdef TEST_FILE
6333 if ( TEST_ALL )
6334 {
6335 TestFileRead();
6336 TestTextFileRead();
6337 TestFileCopy();
6338 }
6339 #endif // TEST_FILE
6340
6341 #ifdef TEST_FILENAME
6342 if ( 0 )
6343 {
6344 wxFileName fn;
6345 fn.Assign(_T("c:\\foo"), _T("bar.baz"));
6346 fn.Assign(_T("/u/os9-port/Viewer/tvision/WEI2HZ-3B3-14_05-04-00MSC1.asc"));
6347
6348 DumpFileName(fn);
6349 }
6350
6351 TestFileNameConstruction();
6352 if ( TEST_ALL )
6353 {
6354 TestFileNameConstruction();
6355 TestFileNameMakeRelative();
6356 TestFileNameSplit();
6357 TestFileNameTemp();
6358 TestFileNameCwd();
6359 TestFileNameComparison();
6360 TestFileNameOperations();
6361 }
6362 #endif // TEST_FILENAME
6363
6364 #ifdef TEST_FILETIME
6365 TestFileGetTimes();
6366 if ( 0 )
6367 TestFileSetTimes();
6368 #endif // TEST_FILETIME
6369
6370 #ifdef TEST_FTP
6371 wxLog::AddTraceMask(FTP_TRACE_MASK);
6372 if ( TestFtpConnect() )
6373 {
6374 if ( TEST_ALL )
6375 {
6376 TestFtpList();
6377 TestFtpDownload();
6378 TestFtpMisc();
6379 TestFtpFileSize();
6380 TestFtpUpload();
6381 }
6382
6383 if ( TEST_INTERACTIVE )
6384 TestFtpInteractive();
6385 }
6386 //else: connecting to the FTP server failed
6387
6388 if ( 0 )
6389 TestFtpWuFtpd();
6390 #endif // TEST_FTP
6391
6392 #ifdef TEST_LONGLONG
6393 // seed pseudo random generator
6394 srand((unsigned)time(NULL));
6395
6396 if ( 0 )
6397 {
6398 TestSpeed();
6399 }
6400
6401 if ( TEST_ALL )
6402 {
6403 TestMultiplication();
6404 TestDivision();
6405 TestAddition();
6406 TestLongLongConversion();
6407 TestBitOperations();
6408 TestLongLongComparison();
6409 TestLongLongPrint();
6410 }
6411 #endif // TEST_LONGLONG
6412
6413 #ifdef TEST_HASH
6414 TestHash();
6415 #endif // TEST_HASH
6416
6417 #ifdef TEST_HASHMAP
6418 TestHashMap();
6419 #endif // TEST_HASHMAP
6420
6421 #ifdef TEST_MIME
6422 wxLog::AddTraceMask(_T("mime"));
6423 if ( TEST_ALL )
6424 {
6425 TestMimeEnum();
6426 TestMimeOverride();
6427 TestMimeAssociate();
6428 }
6429 TestMimeFilename();
6430 #endif // TEST_MIME
6431
6432 #ifdef TEST_INFO_FUNCTIONS
6433 if ( TEST_ALL )
6434 {
6435 TestOsInfo();
6436 TestUserInfo();
6437
6438 if ( TEST_INTERACTIVE )
6439 TestDiskInfo();
6440 }
6441 #endif // TEST_INFO_FUNCTIONS
6442
6443 #ifdef TEST_PATHLIST
6444 TestPathList();
6445 #endif // TEST_PATHLIST
6446
6447 #ifdef TEST_ODBC
6448 TestDbOpen();
6449 #endif // TEST_ODBC
6450
6451 #ifdef TEST_PRINTF
6452 TestPrintf();
6453 #endif // TEST_PRINTF
6454
6455 #ifdef TEST_REGCONF
6456 TestRegConfWrite();
6457 #endif // TEST_REGCONF
6458
6459 #ifdef TEST_REGEX
6460 // TODO: write a real test using src/regex/tests file
6461 if ( TEST_ALL )
6462 {
6463 TestRegExCompile();
6464 TestRegExMatch();
6465 TestRegExSubmatch();
6466 TestRegExReplacement();
6467
6468 if ( TEST_INTERACTIVE )
6469 TestRegExInteractive();
6470 }
6471 #endif // TEST_REGEX
6472
6473 #ifdef TEST_REGISTRY
6474 TestRegistryRead();
6475 TestRegistryAssociation();
6476 #endif // TEST_REGISTRY
6477
6478 #ifdef TEST_SOCKETS
6479 TestSocketServer();
6480 TestSocketClient();
6481 #endif // TEST_SOCKETS
6482
6483 #ifdef TEST_STREAMS
6484 if ( TEST_ALL )
6485 {
6486 TestFileStream();
6487 }
6488 TestMemoryStream();
6489 #endif // TEST_STREAMS
6490
6491 #ifdef TEST_THREADS
6492 int nCPUs = wxThread::GetCPUCount();
6493 wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
6494 if ( nCPUs != -1 )
6495 wxThread::SetConcurrency(nCPUs);
6496
6497 TestDetachedThreads();
6498 if ( TEST_ALL )
6499 {
6500 TestJoinableThreads();
6501 TestThreadSuspend();
6502 TestThreadDelete();
6503 TestThreadConditions();
6504 TestThreadExec();
6505 TestSemaphore();
6506 }
6507 #endif // TEST_THREADS
6508
6509 #ifdef TEST_TIMER
6510 TestStopWatch();
6511 #endif // TEST_TIMER
6512
6513 #ifdef TEST_DATETIME
6514 if ( TEST_ALL )
6515 {
6516 TestTimeSet();
6517 TestTimeStatic();
6518 TestTimeRange();
6519 TestTimeZones();
6520 TestTimeTicks();
6521 TestTimeJDN();
6522 TestTimeDST();
6523 TestTimeWDays();
6524 TestTimeWNumber();
6525 TestTimeParse();
6526 TestTimeArithmetics();
6527 TestTimeHolidays();
6528 TestTimeFormat();
6529 TestTimeSpanFormat();
6530 TestTimeMS();
6531
6532 TestTimeZoneBug();
6533 }
6534 TestTimeFormat();
6535
6536 if ( TEST_INTERACTIVE )
6537 TestDateTimeInteractive();
6538 #endif // TEST_DATETIME
6539
6540 #ifdef TEST_USLEEP
6541 wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
6542 wxUsleep(3000);
6543 #endif // TEST_USLEEP
6544
6545 #ifdef TEST_VCARD
6546 TestVCardRead();
6547 TestVCardWrite();
6548 #endif // TEST_VCARD
6549
6550 #ifdef TEST_VOLUME
6551 TestFSVolume();
6552 #endif // TEST_VOLUME
6553
6554 #ifdef TEST_UNICODE
6555 TestUnicodeToFromAscii();
6556 #endif // TEST_UNICODE
6557
6558 #ifdef TEST_WCHAR
6559 TestUtf8();
6560 TestEncodingConverter();
6561 #endif // TEST_WCHAR
6562
6563 #ifdef TEST_ZIP
6564 TestZipStreamRead();
6565 TestZipFileSystem();
6566 #endif // TEST_ZIP
6567
6568 #ifdef TEST_ZLIB
6569 TestZlibStreamWrite();
6570 TestZlibStreamRead();
6571 #endif // TEST_ZLIB
6572
6573 return 0;
6574 }
6575
wxWidgets (Impactor)