]> git.saurik.com Git - wxWidgets.git/blob - samples/console/console.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
final sweep over docs - replace & with \&
[wxWidgets.git] / samples / console / console.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: samples/console/console.cpp
3 // Purpose: a sample console (as opposed to GUI) progam using wxWidgets
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 04.10.99
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #include "wx/defs.h"
21
22 #include <stdio.h>
23
24 #include "wx/string.h"
25 #include "wx/file.h"
26 #include "wx/app.h"
27 #include "wx/log.h"
28
29 // without this pragma, the stupid compiler precompiles #defines below so that
30 // changing them doesn't "take place" later!
31 #ifdef __VISUALC__
32 #pragma hdrstop
33 #endif
34
35 // ----------------------------------------------------------------------------
36 // conditional compilation
37 // ----------------------------------------------------------------------------
38
39 /*
40 A note about all these conditional compilation macros: this file is used
41 both as a test suite for various non-GUI wxWidgets classes and as a
42 scratchpad for quick tests. So there are two compilation modes: if you
43 define TEST_ALL all tests are run, otherwise you may enable the individual
44 tests individually in the "#else" branch below.
45 */
46
47 // what to test (in alphabetic order)? Define TEST_ALL to 0 to do a single
48 // test, define it to 1 to do all tests.
49 #define TEST_ALL 0
50
51
52 #if TEST_ALL
53 #define TEST_CMDLINE
54 #define TEST_DATETIME
55 #define TEST_DIR
56 #define TEST_DLLLOADER
57 #define TEST_ENVIRON
58 #define TEST_EXECUTE
59 #define TEST_FILE
60 #define TEST_FILECONF
61 #define TEST_FILENAME
62 #define TEST_FILETIME
63 // #define TEST_FTP --FIXME! (RN)
64 #define TEST_HASHMAP
65 #define TEST_HASHSET
66 #define TEST_INFO_FUNCTIONS
67 #define TEST_LIST
68 #define TEST_LOCALE
69 #define TEST_LOG
70 #define TEST_MIME
71 #define TEST_PATHLIST
72 #define TEST_ODBC
73 #define TEST_PRINTF
74 #define TEST_REGCONF
75 #define TEST_REGEX
76 #define TEST_REGISTRY
77 #define TEST_SCOPEGUARD
78 #define TEST_SNGLINST
79 // #define TEST_SOCKETS --FIXME! (RN)
80 #define TEST_STDPATHS
81 #define TEST_STREAMS
82 #define TEST_TEXTSTREAM
83 #define TEST_THREADS
84 #define TEST_TIMER
85 // #define TEST_VCARD -- don't enable this (VZ)
86 // #define TEST_VOLUME --FIXME! (RN)
87 #define TEST_WCHAR
88 #define TEST_ZIP
89 #else // #if TEST_ALL
90 #define TEST_STDPATHS
91 #endif
92
93 // some tests are interactive, define this to run them
94 #ifdef TEST_INTERACTIVE
95 #undef TEST_INTERACTIVE
96
97 #define TEST_INTERACTIVE 1
98 #else
99 #define TEST_INTERACTIVE 0
100 #endif
101
102 // ----------------------------------------------------------------------------
103 // test class for container objects
104 // ----------------------------------------------------------------------------
105
106 #if defined(TEST_LIST)
107
108 class Bar // Foo is already taken in the hash test
109 {
110 public:
111 Bar(const wxString& name) : m_name(name) { ms_bars++; }
112 Bar(const Bar& bar) : m_name(bar.m_name) { ms_bars++; }
113 ~Bar() { ms_bars--; }
114
115 static size_t GetNumber() { return ms_bars; }
116
117 const wxChar *GetName() const { return m_name; }
118
119 private:
120 wxString m_name;
121
122 static size_t ms_bars;
123 };
124
125 size_t Bar::ms_bars = 0;
126
127 #endif // defined(TEST_LIST)
128
129 // ============================================================================
130 // implementation
131 // ============================================================================
132
133 // ----------------------------------------------------------------------------
134 // helper functions
135 // ----------------------------------------------------------------------------
136
137 #if defined(TEST_SOCKETS)
138
139 // replace TABs with \t and CRs with \n
140 static wxString MakePrintable(const wxChar *s)
141 {
142 wxString str(s);
143 (void)str.Replace(_T("\t"), _T("\\t"));
144 (void)str.Replace(_T("\n"), _T("\\n"));
145 (void)str.Replace(_T("\r"), _T("\\r"));
146
147 return str;
148 }
149
150 #endif // MakePrintable() is used
151
152 // ----------------------------------------------------------------------------
153 // wxCmdLineParser
154 // ----------------------------------------------------------------------------
155
156 #ifdef TEST_CMDLINE
157
158 #include "wx/cmdline.h"
159 #include "wx/datetime.h"
160
161 #if wxUSE_CMDLINE_PARSER
162
163 static void ShowCmdLine(const wxCmdLineParser& parser)
164 {
165 wxString s = _T("Input files: ");
166
167 size_t count = parser.GetParamCount();
168 for ( size_t param = 0; param < count; param++ )
169 {
170 s << parser.GetParam(param) << ' ';
171 }
172
173 s << '\n'
174 << _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
175 << _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
176
177 wxString strVal;
178 long lVal;
179 wxDateTime dt;
180 if ( parser.Found(_T("o"), &strVal) )
181 s << _T("Output file:\t") << strVal << '\n';
182 if ( parser.Found(_T("i"), &strVal) )
183 s << _T("Input dir:\t") << strVal << '\n';
184 if ( parser.Found(_T("s"), &lVal) )
185 s << _T("Size:\t") << lVal << '\n';
186 if ( parser.Found(_T("d"), &dt) )
187 s << _T("Date:\t") << dt.FormatISODate() << '\n';
188 if ( parser.Found(_T("project_name"), &strVal) )
189 s << _T("Project:\t") << strVal << '\n';
190
191 wxLogMessage(s);
192 }
193
194 #endif // wxUSE_CMDLINE_PARSER
195
196 static void TestCmdLineConvert()
197 {
198 static const wxChar *cmdlines[] =
199 {
200 _T("arg1 arg2"),
201 _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
202 _T("literal \\\" and \"\""),
203 };
204
205 for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
206 {
207 const wxChar *cmdline = cmdlines[n];
208 wxPrintf(_T("Parsing: %s\n"), cmdline);
209 wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
210
211 size_t count = args.GetCount();
212 wxPrintf(_T("\targc = %u\n"), count);
213 for ( size_t arg = 0; arg < count; arg++ )
214 {
215 wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
216 }
217 }
218 }
219
220 #endif // TEST_CMDLINE
221
222 // ----------------------------------------------------------------------------
223 // wxDir
224 // ----------------------------------------------------------------------------
225
226 #ifdef TEST_DIR
227
228 #include "wx/dir.h"
229
230 #ifdef __UNIX__
231 static const wxChar *ROOTDIR = _T("/");
232 static const wxChar *TESTDIR = _T("/usr/local/share");
233 #elif defined(__WXMSW__)
234 static const wxChar *ROOTDIR = _T("c:\\");
235 static const wxChar *TESTDIR = _T("d:\\");
236 #else
237 #error "don't know where the root directory is"
238 #endif
239
240 static void TestDirEnumHelper(wxDir& dir,
241 int flags = wxDIR_DEFAULT,
242 const wxString& filespec = wxEmptyString)
243 {
244 wxString filename;
245
246 if ( !dir.IsOpened() )
247 return;
248
249 bool cont = dir.GetFirst(&filename, filespec, flags);
250 while ( cont )
251 {
252 wxPrintf(_T("\t%s\n"), filename.c_str());
253
254 cont = dir.GetNext(&filename);
255 }
256
257 wxPuts(wxEmptyString);
258 }
259
260 static void TestDirEnum()
261 {
262 wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
263
264 wxString cwd = wxGetCwd();
265 if ( !wxDir::Exists(cwd) )
266 {
267 wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
268 return;
269 }
270
271 wxDir dir(cwd);
272 if ( !dir.IsOpened() )
273 {
274 wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
275 return;
276 }
277
278 wxPuts(_T("Enumerating everything in current directory:"));
279 TestDirEnumHelper(dir);
280
281 wxPuts(_T("Enumerating really everything in current directory:"));
282 TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
283
284 wxPuts(_T("Enumerating object files in current directory:"));
285 TestDirEnumHelper(dir, wxDIR_DEFAULT, _T("*.o*"));
286
287 wxPuts(_T("Enumerating directories in current directory:"));
288 TestDirEnumHelper(dir, wxDIR_DIRS);
289
290 wxPuts(_T("Enumerating files in current directory:"));
291 TestDirEnumHelper(dir, wxDIR_FILES);
292
293 wxPuts(_T("Enumerating files including hidden in current directory:"));
294 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
295
296 dir.Open(ROOTDIR);
297
298 wxPuts(_T("Enumerating everything in root directory:"));
299 TestDirEnumHelper(dir, wxDIR_DEFAULT);
300
301 wxPuts(_T("Enumerating directories in root directory:"));
302 TestDirEnumHelper(dir, wxDIR_DIRS);
303
304 wxPuts(_T("Enumerating files in root directory:"));
305 TestDirEnumHelper(dir, wxDIR_FILES);
306
307 wxPuts(_T("Enumerating files including hidden in root directory:"));
308 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
309
310 wxPuts(_T("Enumerating files in non existing directory:"));
311 wxDir dirNo(_T("nosuchdir"));
312 TestDirEnumHelper(dirNo);
313 }
314
315 class DirPrintTraverser : public wxDirTraverser
316 {
317 public:
318 virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
319 {
320 return wxDIR_CONTINUE;
321 }
322
323 virtual wxDirTraverseResult OnDir(const wxString& dirname)
324 {
325 wxString path, name, ext;
326 wxSplitPath(dirname, &path, &name, &ext);
327
328 if ( !ext.empty() )
329 name << _T('.') << ext;
330
331 wxString indent;
332 for ( const wxChar *p = path.c_str(); *p; p++ )
333 {
334 if ( wxIsPathSeparator(*p) )
335 indent += _T(" ");
336 }
337
338 wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
339
340 return wxDIR_CONTINUE;
341 }
342 };
343
344 static void TestDirTraverse()
345 {
346 wxPuts(_T("*** Testing wxDir::Traverse() ***"));
347
348 // enum all files
349 wxArrayString files;
350 size_t n = wxDir::GetAllFiles(TESTDIR, &files);
351 wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
352 if ( n > 1 )
353 {
354 wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
355 wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
356 }
357
358 // enum again with custom traverser
359 wxPuts(_T("Now enumerating directories:"));
360 wxDir dir(TESTDIR);
361 DirPrintTraverser traverser;
362 dir.Traverse(traverser, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN);
363 }
364
365 static void TestDirExists()
366 {
367 wxPuts(_T("*** Testing wxDir::Exists() ***"));
368
369 static const wxChar *dirnames[] =
370 {
371 _T("."),
372 #if defined(__WXMSW__)
373 _T("c:"),
374 _T("c:\\"),
375 _T("\\\\share\\file"),
376 _T("c:\\dos"),
377 _T("c:\\dos\\"),
378 _T("c:\\dos\\\\"),
379 _T("c:\\autoexec.bat"),
380 #elif defined(__UNIX__)
381 _T("/"),
382 _T("//"),
383 _T("/usr/bin"),
384 _T("/usr//bin"),
385 _T("/usr///bin"),
386 #endif
387 };
388
389 for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
390 {
391 wxPrintf(_T("%-40s: %s\n"),
392 dirnames[n],
393 wxDir::Exists(dirnames[n]) ? _T("exists")
394 : _T("doesn't exist"));
395 }
396 }
397
398 #endif // TEST_DIR
399
400 // ----------------------------------------------------------------------------
401 // wxDllLoader
402 // ----------------------------------------------------------------------------
403
404 #ifdef TEST_DLLLOADER
405
406 #include "wx/dynlib.h"
407
408 static void TestDllLoad()
409 {
410 #if defined(__WXMSW__)
411 static const wxChar *LIB_NAME = _T("kernel32.dll");
412 static const wxChar *FUNC_NAME = _T("lstrlenA");
413 #elif defined(__UNIX__)
414 // weird: using just libc.so does *not* work!
415 static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
416 static const wxChar *FUNC_NAME = _T("strlen");
417 #else
418 #error "don't know how to test wxDllLoader on this platform"
419 #endif
420
421 wxPuts(_T("*** testing wxDllLoader ***\n"));
422
423 wxDynamicLibrary lib(LIB_NAME);
424 if ( !lib.IsLoaded() )
425 {
426 wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
427 }
428 else
429 {
430 typedef int (*wxStrlenType)(const char *);
431 wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
432 if ( !pfnStrlen )
433 {
434 wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
435 FUNC_NAME, LIB_NAME);
436 }
437 else
438 {
439 if ( pfnStrlen("foo") != 3 )
440 {
441 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
442 }
443 else
444 {
445 wxPuts(_T("... ok"));
446 }
447 }
448 }
449 }
450
451 #endif // TEST_DLLLOADER
452
453 // ----------------------------------------------------------------------------
454 // wxGet/SetEnv
455 // ----------------------------------------------------------------------------
456
457 #ifdef TEST_ENVIRON
458
459 #include "wx/utils.h"
460
461 static wxString MyGetEnv(const wxString& var)
462 {
463 wxString val;
464 if ( !wxGetEnv(var, &val) )
465 val = _T("<empty>");
466 else
467 val = wxString(_T('\'')) + val + _T('\'');
468
469 return val;
470 }
471
472 static void TestEnvironment()
473 {
474 const wxChar *var = _T("wxTestVar");
475
476 wxPuts(_T("*** testing environment access functions ***"));
477
478 wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
479 wxSetEnv(var, _T("value for wxTestVar"));
480 wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
481 wxSetEnv(var, _T("another value"));
482 wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
483 wxUnsetEnv(var);
484 wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
485 wxPrintf(_T("PATH = %s\n"), MyGetEnv(_T("PATH")).c_str());
486 }
487
488 #endif // TEST_ENVIRON
489
490 // ----------------------------------------------------------------------------
491 // wxExecute
492 // ----------------------------------------------------------------------------
493
494 #ifdef TEST_EXECUTE
495
496 #include "wx/utils.h"
497
498 static void TestExecute()
499 {
500 wxPuts(_T("*** testing wxExecute ***"));
501
502 #ifdef __UNIX__
503 #define COMMAND "cat -n ../../Makefile" // "echo hi"
504 #define SHELL_COMMAND "echo hi from shell"
505 #define REDIRECT_COMMAND COMMAND // "date"
506 #elif defined(__WXMSW__)
507 #define COMMAND "command.com /c echo hi"
508 #define SHELL_COMMAND "echo hi"
509 #define REDIRECT_COMMAND COMMAND
510 #else
511 #error "no command to exec"
512 #endif // OS
513
514 wxPrintf(_T("Testing wxShell: "));
515 fflush(stdout);
516 if ( wxShell(_T(SHELL_COMMAND)) )
517 wxPuts(_T("Ok."));
518 else
519 wxPuts(_T("ERROR."));
520
521 wxPrintf(_T("Testing wxExecute: "));
522 fflush(stdout);
523 if ( wxExecute(_T(COMMAND), true /* sync */) == 0 )
524 wxPuts(_T("Ok."));
525 else
526 wxPuts(_T("ERROR."));
527
528 #if 0 // no, it doesn't work (yet?)
529 wxPrintf(_T("Testing async wxExecute: "));
530 fflush(stdout);
531 if ( wxExecute(COMMAND) != 0 )
532 wxPuts(_T("Ok (command launched)."));
533 else
534 wxPuts(_T("ERROR."));
535 #endif // 0
536
537 wxPrintf(_T("Testing wxExecute with redirection:\n"));
538 wxArrayString output;
539 if ( wxExecute(_T(REDIRECT_COMMAND), output) != 0 )
540 {
541 wxPuts(_T("ERROR."));
542 }
543 else
544 {
545 size_t count = output.GetCount();
546 for ( size_t n = 0; n < count; n++ )
547 {
548 wxPrintf(_T("\t%s\n"), output[n].c_str());
549 }
550
551 wxPuts(_T("Ok."));
552 }
553 }
554
555 #endif // TEST_EXECUTE
556
557 // ----------------------------------------------------------------------------
558 // file
559 // ----------------------------------------------------------------------------
560
561 #ifdef TEST_FILE
562
563 #include "wx/file.h"
564 #include "wx/ffile.h"
565 #include "wx/textfile.h"
566
567 static void TestFileRead()
568 {
569 wxPuts(_T("*** wxFile read test ***"));
570
571 wxFile file(_T("testdata.fc"));
572 if ( file.IsOpened() )
573 {
574 wxPrintf(_T("File length: %lu\n"), file.Length());
575
576 wxPuts(_T("File dump:\n----------"));
577
578 static const off_t len = 1024;
579 wxChar buf[len];
580 for ( ;; )
581 {
582 off_t nRead = file.Read(buf, len);
583 if ( nRead == wxInvalidOffset )
584 {
585 wxPrintf(_T("Failed to read the file."));
586 break;
587 }
588
589 fwrite(buf, nRead, 1, stdout);
590
591 if ( nRead < len )
592 break;
593 }
594
595 wxPuts(_T("----------"));
596 }
597 else
598 {
599 wxPrintf(_T("ERROR: can't open test file.\n"));
600 }
601
602 wxPuts(wxEmptyString);
603 }
604
605 static void TestTextFileRead()
606 {
607 wxPuts(_T("*** wxTextFile read test ***"));
608
609 wxTextFile file(_T("testdata.fc"));
610 if ( file.Open() )
611 {
612 wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
613 wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
614
615 wxString s;
616
617 wxPuts(_T("\nDumping the entire file:"));
618 for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
619 {
620 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
621 }
622 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
623
624 wxPuts(_T("\nAnd now backwards:"));
625 for ( s = file.GetLastLine();
626 file.GetCurrentLine() != 0;
627 s = file.GetPrevLine() )
628 {
629 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
630 }
631 wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
632 }
633 else
634 {
635 wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
636 }
637
638 wxPuts(wxEmptyString);
639 }
640
641 static void TestFileCopy()
642 {
643 wxPuts(_T("*** Testing wxCopyFile ***"));
644
645 static const wxChar *filename1 = _T("testdata.fc");
646 static const wxChar *filename2 = _T("test2");
647 if ( !wxCopyFile(filename1, filename2) )
648 {
649 wxPuts(_T("ERROR: failed to copy file"));
650 }
651 else
652 {
653 wxFFile f1(filename1, _T("rb")),
654 f2(filename2, _T("rb"));
655
656 if ( !f1.IsOpened() || !f2.IsOpened() )
657 {
658 wxPuts(_T("ERROR: failed to open file(s)"));
659 }
660 else
661 {
662 wxString s1, s2;
663 if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
664 {
665 wxPuts(_T("ERROR: failed to read file(s)"));
666 }
667 else
668 {
669 if ( (s1.length() != s2.length()) ||
670 (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
671 {
672 wxPuts(_T("ERROR: copy error!"));
673 }
674 else
675 {
676 wxPuts(_T("File was copied ok."));
677 }
678 }
679 }
680 }
681
682 if ( !wxRemoveFile(filename2) )
683 {
684 wxPuts(_T("ERROR: failed to remove the file"));
685 }
686
687 wxPuts(wxEmptyString);
688 }
689
690 #endif // TEST_FILE
691
692 // ----------------------------------------------------------------------------
693 // wxFileConfig
694 // ----------------------------------------------------------------------------
695
696 #ifdef TEST_FILECONF
697
698 #include "wx/confbase.h"
699 #include "wx/fileconf.h"
700
701 static const struct FileConfTestData
702 {
703 const wxChar *name; // value name
704 const wxChar *value; // the value from the file
705 } fcTestData[] =
706 {
707 { _T("value1"), _T("one") },
708 { _T("value2"), _T("two") },
709 { _T("novalue"), _T("default") },
710 };
711
712 static void TestFileConfRead()
713 {
714 wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
715
716 wxFileConfig fileconf(_T("test"), wxEmptyString,
717 _T("testdata.fc"), wxEmptyString,
718 wxCONFIG_USE_RELATIVE_PATH);
719
720 // test simple reading
721 wxPuts(_T("\nReading config file:"));
722 wxString defValue(_T("default")), value;
723 for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
724 {
725 const FileConfTestData& data = fcTestData[n];
726 value = fileconf.Read(data.name, defValue);
727 wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
728 if ( value == data.value )
729 {
730 wxPuts(_T("(ok)"));
731 }
732 else
733 {
734 wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
735 }
736 }
737
738 // test enumerating the entries
739 wxPuts(_T("\nEnumerating all root entries:"));
740 long dummy;
741 wxString name;
742 bool cont = fileconf.GetFirstEntry(name, dummy);
743 while ( cont )
744 {
745 wxPrintf(_T("\t%s = %s\n"),
746 name.c_str(),
747 fileconf.Read(name.c_str(), _T("ERROR")).c_str());
748
749 cont = fileconf.GetNextEntry(name, dummy);
750 }
751
752 static const wxChar *testEntry = _T("TestEntry");
753 wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
754 fileconf.Write(testEntry, _T("A value"));
755 fileconf.DeleteEntry(testEntry);
756 wxPrintf(fileconf.HasEntry(testEntry) ? _T("ERROR\n") : _T("ok\n"));
757 }
758
759 #endif // TEST_FILECONF
760
761 // ----------------------------------------------------------------------------
762 // wxFileName
763 // ----------------------------------------------------------------------------
764
765 #ifdef TEST_FILENAME
766
767 #include "wx/filename.h"
768
769 #if 0
770 static void DumpFileName(const wxChar *desc, const wxFileName& fn)
771 {
772 wxPuts(desc);
773
774 wxString full = fn.GetFullPath();
775
776 wxString vol, path, name, ext;
777 wxFileName::SplitPath(full, &vol, &path, &name, &ext);
778
779 wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
780 full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
781
782 wxFileName::SplitPath(full, &path, &name, &ext);
783 wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
784 path.c_str(), name.c_str(), ext.c_str());
785
786 wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
787 wxPrintf(_T("with volume: \t'%s'\n"),
788 fn.GetPath(wxPATH_GET_VOLUME).c_str());
789 wxPrintf(_T("with separator:\t'%s'\n"),
790 fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
791 wxPrintf(_T("with both: \t'%s'\n"),
792 fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
793
794 wxPuts(_T("The directories in the path are:"));
795 wxArrayString dirs = fn.GetDirs();
796 size_t count = dirs.GetCount();
797 for ( size_t n = 0; n < count; n++ )
798 {
799 wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
800 }
801 }
802 #endif
803
804 static void TestFileNameTemp()
805 {
806 wxPuts(_T("*** testing wxFileName temp file creation ***"));
807
808 static const wxChar *tmpprefixes[] =
809 {
810 _T(""),
811 _T("foo"),
812 _T(".."),
813 _T("../bar"),
814 #ifdef __UNIX__
815 _T("/tmp/foo"),
816 _T("/tmp/foo/bar"), // this one must be an error
817 #endif // __UNIX__
818 };
819
820 for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
821 {
822 wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
823 if ( path.empty() )
824 {
825 // "error" is not in upper case because it may be ok
826 wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
827 }
828 else
829 {
830 wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
831 tmpprefixes[n], path.c_str());
832
833 if ( !wxRemoveFile(path) )
834 {
835 wxLogWarning(_T("Failed to remove temp file '%s'"),
836 path.c_str());
837 }
838 }
839 }
840 }
841
842 static void TestFileNameMakeRelative()
843 {
844 wxPuts(_T("*** testing wxFileName::MakeRelativeTo() ***"));
845
846 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
847 {
848 const FileNameInfo& fni = filenames[n];
849
850 wxFileName fn(fni.fullname, fni.format);
851
852 // choose the base dir of the same format
853 wxString base;
854 switch ( fni.format )
855 {
856 case wxPATH_UNIX:
857 base = _T("/usr/bin/");
858 break;
859
860 case wxPATH_DOS:
861 base = _T("c:\\");
862 break;
863
864 case wxPATH_MAC:
865 case wxPATH_VMS:
866 // TODO: I don't know how this is supposed to work there
867 continue;
868
869 case wxPATH_NATIVE: // make gcc happy
870 default:
871 wxFAIL_MSG( _T("unexpected path format") );
872 }
873
874 wxPrintf(_T("'%s' relative to '%s': "),
875 fn.GetFullPath(fni.format).c_str(), base.c_str());
876
877 if ( !fn.MakeRelativeTo(base, fni.format) )
878 {
879 wxPuts(_T("unchanged"));
880 }
881 else
882 {
883 wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
884 }
885 }
886 }
887
888 static void TestFileNameMakeAbsolute()
889 {
890 wxPuts(_T("*** testing wxFileName::MakeAbsolute() ***"));
891
892 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
893 {
894 const FileNameInfo& fni = filenames[n];
895 wxFileName fn(fni.fullname, fni.format);
896
897 wxPrintf(_T("'%s' absolutized: "),
898 fn.GetFullPath(fni.format).c_str());
899 fn.MakeAbsolute();
900 wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
901 }
902
903 wxPuts(wxEmptyString);
904 }
905
906 static void TestFileNameDirManip()
907 {
908 // TODO: test AppendDir(), RemoveDir(), ...
909 }
910
911 static void TestFileNameComparison()
912 {
913 // TODO!
914 }
915
916 static void TestFileNameOperations()
917 {
918 // TODO!
919 }
920
921 static void TestFileNameCwd()
922 {
923 // TODO!
924 }
925
926 #endif // TEST_FILENAME
927
928 // ----------------------------------------------------------------------------
929 // wxFileName time functions
930 // ----------------------------------------------------------------------------
931
932 #ifdef TEST_FILETIME
933
934 #include <wx/filename.h>
935 #include <wx/datetime.h>
936
937 static void TestFileGetTimes()
938 {
939 wxFileName fn(_T("testdata.fc"));
940
941 wxDateTime dtAccess, dtMod, dtCreate;
942 if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
943 {
944 wxPrintf(_T("ERROR: GetTimes() failed.\n"));
945 }
946 else
947 {
948 static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
949
950 wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
951 wxPrintf(_T("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
952 wxPrintf(_T("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
953 wxPrintf(_T("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
954 }
955 }
956
957 #if 0
958 static void TestFileSetTimes()
959 {
960 wxFileName fn(_T("testdata.fc"));
961
962 if ( !fn.Touch() )
963 {
964 wxPrintf(_T("ERROR: Touch() failed.\n"));
965 }
966 }
967 #endif
968
969 #endif // TEST_FILETIME
970
971 // ----------------------------------------------------------------------------
972 // wxHashMap
973 // ----------------------------------------------------------------------------
974
975 #ifdef TEST_HASHMAP
976
977 #include "wx/hashmap.h"
978
979 // test compilation of basic map types
980 WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash, wxPointerEqual, myPtrHashMap );
981 WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
982 WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
983 myUnsignedHashMap );
984 WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
985 myTestHashMap1 );
986 WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
987 myTestHashMap2 );
988 WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
989 myTestHashMap3 );
990 WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
991 myTestHashMap4 );
992
993 // same as:
994 // WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
995 // myStringHashMap );
996 WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
997
998 typedef myStringHashMap::iterator Itor;
999
1000 static void TestHashMap()
1001 {
1002 wxPuts(_T("*** Testing wxHashMap ***\n"));
1003 myStringHashMap sh(0); // as small as possible
1004 wxString buf;
1005 size_t i;
1006 const size_t count = 10000;
1007
1008 // init with some data
1009 for( i = 0; i < count; ++i )
1010 {
1011 buf.Printf(wxT("%d"), i );
1012 sh[buf] = wxT("A") + buf + wxT("C");
1013 }
1014
1015 // test that insertion worked
1016 if( sh.size() != count )
1017 {
1018 wxPrintf(_T("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n"), sh.size(), count);
1019 }
1020
1021 for( i = 0; i < count; ++i )
1022 {
1023 buf.Printf(wxT("%d"), i );
1024 if( sh[buf] != wxT("A") + buf + wxT("C") )
1025 {
1026 wxPrintf(_T("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n"));
1027 return;
1028 }
1029 }
1030
1031 // check that iterators work
1032 Itor it;
1033 for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1034 {
1035 if( i == count )
1036 {
1037 wxPrintf(_T("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n"));
1038 return;
1039 }
1040
1041 if( it->second != sh[it->first] )
1042 {
1043 wxPrintf(_T("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n"));
1044 return;
1045 }
1046 }
1047
1048 if( sh.size() != i )
1049 {
1050 wxPrintf(_T("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n"), i, count);
1051 }
1052
1053 // test copy ctor, assignment operator
1054 myStringHashMap h1( sh ), h2( 0 );
1055 h2 = sh;
1056
1057 for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
1058 {
1059 if( h1[it->first] != it->second )
1060 {
1061 wxPrintf(_T("*** ERROR: COPY CTOR BROKEN %s ***\n"), it->first.c_str());
1062 }
1063
1064 if( h2[it->first] != it->second )
1065 {
1066 wxPrintf(_T("*** ERROR: OPERATOR= BROKEN %s ***\n"), it->first.c_str());
1067 }
1068 }
1069
1070 // other tests
1071 for( i = 0; i < count; ++i )
1072 {
1073 buf.Printf(wxT("%d"), i );
1074 size_t sz = sh.size();
1075
1076 // test find() and erase(it)
1077 if( i < 100 )
1078 {
1079 it = sh.find( buf );
1080 if( it != sh.end() )
1081 {
1082 sh.erase( it );
1083
1084 if( sh.find( buf ) != sh.end() )
1085 {
1086 wxPrintf(_T("*** ERROR: FOUND DELETED ELEMENT %u ***\n"), i);
1087 }
1088 }
1089 else
1090 wxPrintf(_T("*** ERROR: CANT FIND ELEMENT %u ***\n"), i);
1091 }
1092 else
1093 // test erase(key)
1094 {
1095 size_t c = sh.erase( buf );
1096 if( c != 1 )
1097 wxPrintf(_T("*** ERROR: SHOULD RETURN 1 ***\n"));
1098
1099 if( sh.find( buf ) != sh.end() )
1100 {
1101 wxPrintf(_T("*** ERROR: FOUND DELETED ELEMENT %u ***\n"), i);
1102 }
1103 }
1104
1105 // count should decrease
1106 if( sh.size() != sz - 1 )
1107 {
1108 wxPrintf(_T("*** ERROR: COUNT DID NOT DECREASE ***\n"));
1109 }
1110 }
1111
1112 wxPrintf(_T("*** Finished testing wxHashMap ***\n"));
1113 }
1114
1115 #endif // TEST_HASHMAP
1116
1117 // ----------------------------------------------------------------------------
1118 // wxHashSet
1119 // ----------------------------------------------------------------------------
1120
1121 #ifdef TEST_HASHSET
1122
1123 #include "wx/hashset.h"
1124
1125 // test compilation of basic map types
1126 WX_DECLARE_HASH_SET( int*, wxPointerHash, wxPointerEqual, myPtrHashSet );
1127 WX_DECLARE_HASH_SET( long, wxIntegerHash, wxIntegerEqual, myLongHashSet );
1128 WX_DECLARE_HASH_SET( unsigned long, wxIntegerHash, wxIntegerEqual,
1129 myUnsignedHashSet );
1130 WX_DECLARE_HASH_SET( unsigned int, wxIntegerHash, wxIntegerEqual,
1131 myTestHashSet1 );
1132 WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual,
1133 myTestHashSet2 );
1134 WX_DECLARE_HASH_SET( short, wxIntegerHash, wxIntegerEqual,
1135 myTestHashSet3 );
1136 WX_DECLARE_HASH_SET( unsigned short, wxIntegerHash, wxIntegerEqual,
1137 myTestHashSet4 );
1138 WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual,
1139 myTestHashSet5 );
1140
1141 struct MyStruct
1142 {
1143 int* ptr;
1144 wxString str;
1145 };
1146
1147 class MyHash
1148 {
1149 public:
1150 unsigned long operator()(const MyStruct& s) const
1151 { return m_dummy(s.ptr); }
1152 MyHash& operator=(const MyHash&) { return *this; }
1153 private:
1154 wxPointerHash m_dummy;
1155 };
1156
1157 class MyEqual
1158 {
1159 public:
1160 bool operator()(const MyStruct& s1, const MyStruct& s2) const
1161 { return s1.ptr == s2.ptr; }
1162 MyEqual& operator=(const MyEqual&) { return *this; }
1163 };
1164
1165 WX_DECLARE_HASH_SET( MyStruct, MyHash, MyEqual, mySet );
1166
1167 typedef myTestHashSet5 wxStringHashSet;
1168
1169 static void TestHashSet()
1170 {
1171 wxPrintf(_T("*** Testing wxHashSet ***\n"));
1172
1173 wxStringHashSet set1;
1174
1175 set1.insert( _T("abc") );
1176 set1.insert( _T("bbc") );
1177 set1.insert( _T("cbc") );
1178 set1.insert( _T("abc") );
1179
1180 if( set1.size() != 3 )
1181 wxPrintf(_T("*** ERROR IN INSERT ***\n"));
1182
1183 mySet set2;
1184 int dummy;
1185 MyStruct tmp;
1186
1187 tmp.ptr = &dummy; tmp.str = _T("ABC");
1188 set2.insert( tmp );
1189 tmp.ptr = &dummy + 1;
1190 set2.insert( tmp );
1191 tmp.ptr = &dummy; tmp.str = _T("CDE");
1192 set2.insert( tmp );
1193
1194 if( set2.size() != 2 )
1195 wxPrintf(_T("*** ERROR IN INSERT - 2 ***\n"));
1196
1197 mySet::iterator it = set2.find( tmp );
1198
1199 if( it == set2.end() )
1200 wxPrintf(_T("*** ERROR IN FIND - 1 ***\n"));
1201 if( it->ptr != &dummy )
1202 wxPrintf(_T("*** ERROR IN FIND - 2 ***\n"));
1203 if( it->str != _T("ABC") )
1204 wxPrintf(_T("*** ERROR IN INSERT - 3 ***\n"));
1205
1206 wxPrintf(_T("*** Finished testing wxHashSet ***\n"));
1207 }
1208
1209 #endif // TEST_HASHSET
1210
1211 // ----------------------------------------------------------------------------
1212 // wxList
1213 // ----------------------------------------------------------------------------
1214
1215 #ifdef TEST_LIST
1216
1217 #include "wx/list.h"
1218
1219 WX_DECLARE_LIST(Bar, wxListBars);
1220 #include "wx/listimpl.cpp"
1221 WX_DEFINE_LIST(wxListBars);
1222
1223 WX_DECLARE_LIST(int, wxListInt);
1224 WX_DEFINE_LIST(wxListInt);
1225
1226 static void TestList()
1227 {
1228 wxPuts(_T("*** Testing wxList operations ***\n"));
1229 {
1230 wxListInt list1;
1231 int dummy[5];
1232 int i;
1233
1234 for ( i = 0; i < 5; ++i )
1235 list1.Append(dummy + i);
1236
1237 if ( list1.GetCount() != 5 )
1238 wxPuts(_T("Wrong number of items in list\n"));
1239
1240 if ( list1.Item(3)->GetData() != dummy + 3 )
1241 wxPuts(_T("Error in Item()\n"));
1242
1243 if ( !list1.Find(dummy + 4) )
1244 wxPuts(_T("Error in Find()\n"));
1245
1246 wxListInt::compatibility_iterator node = list1.GetFirst();
1247 i = 0;
1248
1249 while (node)
1250 {
1251 if ( node->GetData() != dummy + i )
1252 wxPuts(_T("Error in compatibility_iterator\n"));
1253 node = node->GetNext();
1254 ++i;
1255 }
1256
1257 if ( size_t(i) != list1.GetCount() )
1258 wxPuts(_T("Error in compatibility_iterator\n"));
1259
1260 list1.Insert(dummy + 0);
1261 list1.Insert(1, dummy + 1);
1262 list1.Insert(list1.GetFirst()->GetNext()->GetNext(), dummy + 2);
1263
1264 node = list1.GetFirst();
1265 i = 0;
1266
1267 while (i < 3)
1268 {
1269 int* t = node->GetData();
1270 if ( t != dummy + i )
1271 wxPuts(_T("Error in Insert\n"));
1272 node = node->GetNext();
1273 ++i;
1274 }
1275 }
1276
1277 wxPuts(_T("*** Testing wxList operations finished ***\n"));
1278
1279 wxPuts(_T("*** Testing std::list operations ***\n"));
1280
1281 {
1282 wxListInt list1;
1283 wxListInt::iterator it, en;
1284 wxListInt::reverse_iterator rit, ren;
1285 int i;
1286 for ( i = 0; i < 5; ++i )
1287 list1.push_back(i + &i);
1288
1289 for ( it = list1.begin(), en = list1.end(), i = 0;
1290 it != en; ++it, ++i )
1291 if ( *it != i + &i )
1292 wxPuts(_T("Error in iterator\n"));
1293
1294 for ( rit = list1.rbegin(), ren = list1.rend(), i = 4;
1295 rit != ren; ++rit, --i )
1296 if ( *rit != i + &i )
1297 wxPuts(_T("Error in reverse_iterator\n"));
1298
1299 if ( *list1.rbegin() != *--list1.end() ||
1300 *list1.begin() != *--list1.rend() )
1301 wxPuts(_T("Error in iterator/reverse_iterator\n"));
1302 if ( *list1.begin() != *--++list1.begin() ||
1303 *list1.rbegin() != *--++list1.rbegin() )
1304 wxPuts(_T("Error in iterator/reverse_iterator\n"));
1305
1306 if ( list1.front() != &i || list1.back() != &i + 4 )
1307 wxPuts(_T("Error in front()/back()\n"));
1308
1309 list1.erase(list1.begin());
1310 list1.erase(--list1.end());
1311
1312 for ( it = list1.begin(), en = list1.end(), i = 1;
1313 it != en; ++it, ++i )
1314 if ( *it != i + &i )
1315 wxPuts(_T("Error in erase()\n"));
1316 }
1317
1318 wxPuts(_T("*** Testing std::list operations finished ***\n"));
1319 }
1320
1321 static void TestListCtor()
1322 {
1323 wxPuts(_T("*** Testing wxList construction ***\n"));
1324
1325 {
1326 wxListBars list1;
1327 list1.Append(new Bar(_T("first")));
1328 list1.Append(new Bar(_T("second")));
1329
1330 wxPrintf(_T("After 1st list creation: %u objects in the list, %u objects total.\n"),
1331 list1.GetCount(), Bar::GetNumber());
1332
1333 wxListBars list2;
1334 list2 = list1;
1335
1336 wxPrintf(_T("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n"),
1337 list1.GetCount(), list2.GetCount(), Bar::GetNumber());
1338
1339 #if !wxUSE_STL
1340 list1.DeleteContents(true);
1341 #else
1342 WX_CLEAR_LIST(wxListBars, list1);
1343 #endif
1344 }
1345
1346 wxPrintf(_T("After list destruction: %u objects left.\n"), Bar::GetNumber());
1347 }
1348
1349 #endif // TEST_LIST
1350
1351 // ----------------------------------------------------------------------------
1352 // wxLocale
1353 // ----------------------------------------------------------------------------
1354
1355 #ifdef TEST_LOCALE
1356
1357 #include "wx/intl.h"
1358 #include "wx/utils.h" // for wxSetEnv
1359
1360 static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
1361
1362 // find the name of the language from its value
1363 static const wxChar *GetLangName(int lang)
1364 {
1365 static const wxChar *languageNames[] =
1366 {
1367 _T("DEFAULT"),
1368 _T("UNKNOWN"),
1369 _T("ABKHAZIAN"),
1370 _T("AFAR"),
1371 _T("AFRIKAANS"),
1372 _T("ALBANIAN"),
1373 _T("AMHARIC"),
1374 _T("ARABIC"),
1375 _T("ARABIC_ALGERIA"),
1376 _T("ARABIC_BAHRAIN"),
1377 _T("ARABIC_EGYPT"),
1378 _T("ARABIC_IRAQ"),
1379 _T("ARABIC_JORDAN"),
1380 _T("ARABIC_KUWAIT"),
1381 _T("ARABIC_LEBANON"),
1382 _T("ARABIC_LIBYA"),
1383 _T("ARABIC_MOROCCO"),
1384 _T("ARABIC_OMAN"),
1385 _T("ARABIC_QATAR"),
1386 _T("ARABIC_SAUDI_ARABIA"),
1387 _T("ARABIC_SUDAN"),
1388 _T("ARABIC_SYRIA"),
1389 _T("ARABIC_TUNISIA"),
1390 _T("ARABIC_UAE"),
1391 _T("ARABIC_YEMEN"),
1392 _T("ARMENIAN"),
1393 _T("ASSAMESE"),
1394 _T("AYMARA"),
1395 _T("AZERI"),
1396 _T("AZERI_CYRILLIC"),
1397 _T("AZERI_LATIN"),
1398 _T("BASHKIR"),
1399 _T("BASQUE"),
1400 _T("BELARUSIAN"),
1401 _T("BENGALI"),
1402 _T("BHUTANI"),
1403 _T("BIHARI"),
1404 _T("BISLAMA"),
1405 _T("BRETON"),
1406 _T("BULGARIAN"),
1407 _T("BURMESE"),
1408 _T("CAMBODIAN"),
1409 _T("CATALAN"),
1410 _T("CHINESE"),
1411 _T("CHINESE_SIMPLIFIED"),
1412 _T("CHINESE_TRADITIONAL"),
1413 _T("CHINESE_HONGKONG"),
1414 _T("CHINESE_MACAU"),
1415 _T("CHINESE_SINGAPORE"),
1416 _T("CHINESE_TAIWAN"),
1417 _T("CORSICAN"),
1418 _T("CROATIAN"),
1419 _T("CZECH"),
1420 _T("DANISH"),
1421 _T("DUTCH"),
1422 _T("DUTCH_BELGIAN"),
1423 _T("ENGLISH"),
1424 _T("ENGLISH_UK"),
1425 _T("ENGLISH_US"),
1426 _T("ENGLISH_AUSTRALIA"),
1427 _T("ENGLISH_BELIZE"),
1428 _T("ENGLISH_BOTSWANA"),
1429 _T("ENGLISH_CANADA"),
1430 _T("ENGLISH_CARIBBEAN"),
1431 _T("ENGLISH_DENMARK"),
1432 _T("ENGLISH_EIRE"),
1433 _T("ENGLISH_JAMAICA"),
1434 _T("ENGLISH_NEW_ZEALAND"),
1435 _T("ENGLISH_PHILIPPINES"),
1436 _T("ENGLISH_SOUTH_AFRICA"),
1437 _T("ENGLISH_TRINIDAD"),
1438 _T("ENGLISH_ZIMBABWE"),
1439 _T("ESPERANTO"),
1440 _T("ESTONIAN"),
1441 _T("FAEROESE"),
1442 _T("FARSI"),
1443 _T("FIJI"),
1444 _T("FINNISH"),
1445 _T("FRENCH"),
1446 _T("FRENCH_BELGIAN"),
1447 _T("FRENCH_CANADIAN"),
1448 _T("FRENCH_LUXEMBOURG"),
1449 _T("FRENCH_MONACO"),
1450 _T("FRENCH_SWISS"),
1451 _T("FRISIAN"),
1452 _T("GALICIAN"),
1453 _T("GEORGIAN"),
1454 _T("GERMAN"),
1455 _T("GERMAN_AUSTRIAN"),
1456 _T("GERMAN_BELGIUM"),
1457 _T("GERMAN_LIECHTENSTEIN"),
1458 _T("GERMAN_LUXEMBOURG"),
1459 _T("GERMAN_SWISS"),
1460 _T("GREEK"),
1461 _T("GREENLANDIC"),
1462 _T("GUARANI"),
1463 _T("GUJARATI"),
1464 _T("HAUSA"),
1465 _T("HEBREW"),
1466 _T("HINDI"),
1467 _T("HUNGARIAN"),
1468 _T("ICELANDIC"),
1469 _T("INDONESIAN"),
1470 _T("INTERLINGUA"),
1471 _T("INTERLINGUE"),
1472 _T("INUKTITUT"),
1473 _T("INUPIAK"),
1474 _T("IRISH"),
1475 _T("ITALIAN"),
1476 _T("ITALIAN_SWISS"),
1477 _T("JAPANESE"),
1478 _T("JAVANESE"),
1479 _T("KANNADA"),
1480 _T("KASHMIRI"),
1481 _T("KASHMIRI_INDIA"),
1482 _T("KAZAKH"),
1483 _T("KERNEWEK"),
1484 _T("KINYARWANDA"),
1485 _T("KIRGHIZ"),
1486 _T("KIRUNDI"),
1487 _T("KONKANI"),
1488 _T("KOREAN"),
1489 _T("KURDISH"),
1490 _T("LAOTHIAN"),
1491 _T("LATIN"),
1492 _T("LATVIAN"),
1493 _T("LINGALA"),
1494 _T("LITHUANIAN"),
1495 _T("MACEDONIAN"),
1496 _T("MALAGASY"),
1497 _T("MALAY"),
1498 _T("MALAYALAM"),
1499 _T("MALAY_BRUNEI_DARUSSALAM"),
1500 _T("MALAY_MALAYSIA"),
1501 _T("MALTESE"),
1502 _T("MANIPURI"),
1503 _T("MAORI"),
1504 _T("MARATHI"),
1505 _T("MOLDAVIAN"),
1506 _T("MONGOLIAN"),
1507 _T("NAURU"),
1508 _T("NEPALI"),
1509 _T("NEPALI_INDIA"),
1510 _T("NORWEGIAN_BOKMAL"),
1511 _T("NORWEGIAN_NYNORSK"),
1512 _T("OCCITAN"),
1513 _T("ORIYA"),
1514 _T("OROMO"),
1515 _T("PASHTO"),
1516 _T("POLISH"),
1517 _T("PORTUGUESE"),
1518 _T("PORTUGUESE_BRAZILIAN"),
1519 _T("PUNJABI"),
1520 _T("QUECHUA"),
1521 _T("RHAETO_ROMANCE"),
1522 _T("ROMANIAN"),
1523 _T("RUSSIAN"),
1524 _T("RUSSIAN_UKRAINE"),
1525 _T("SAMOAN"),
1526 _T("SANGHO"),
1527 _T("SANSKRIT"),
1528 _T("SCOTS_GAELIC"),
1529 _T("SERBIAN"),
1530 _T("SERBIAN_CYRILLIC"),
1531 _T("SERBIAN_LATIN"),
1532 _T("SERBO_CROATIAN"),
1533 _T("SESOTHO"),
1534 _T("SETSWANA"),
1535 _T("SHONA"),
1536 _T("SINDHI"),
1537 _T("SINHALESE"),
1538 _T("SISWATI"),
1539 _T("SLOVAK"),
1540 _T("SLOVENIAN"),
1541 _T("SOMALI"),
1542 _T("SPANISH"),
1543 _T("SPANISH_ARGENTINA"),
1544 _T("SPANISH_BOLIVIA"),
1545 _T("SPANISH_CHILE"),
1546 _T("SPANISH_COLOMBIA"),
1547 _T("SPANISH_COSTA_RICA"),
1548 _T("SPANISH_DOMINICAN_REPUBLIC"),
1549 _T("SPANISH_ECUADOR"),
1550 _T("SPANISH_EL_SALVADOR"),
1551 _T("SPANISH_GUATEMALA"),
1552 _T("SPANISH_HONDURAS"),
1553 _T("SPANISH_MEXICAN"),
1554 _T("SPANISH_MODERN"),
1555 _T("SPANISH_NICARAGUA"),
1556 _T("SPANISH_PANAMA"),
1557 _T("SPANISH_PARAGUAY"),
1558 _T("SPANISH_PERU"),
1559 _T("SPANISH_PUERTO_RICO"),
1560 _T("SPANISH_URUGUAY"),
1561 _T("SPANISH_US"),
1562 _T("SPANISH_VENEZUELA"),
1563 _T("SUNDANESE"),
1564 _T("SWAHILI"),
1565 _T("SWEDISH"),
1566 _T("SWEDISH_FINLAND"),
1567 _T("TAGALOG"),
1568 _T("TAJIK"),
1569 _T("TAMIL"),
1570 _T("TATAR"),
1571 _T("TELUGU"),
1572 _T("THAI"),
1573 _T("TIBETAN"),
1574 _T("TIGRINYA"),
1575 _T("TONGA"),
1576 _T("TSONGA"),
1577 _T("TURKISH"),
1578 _T("TURKMEN"),
1579 _T("TWI"),
1580 _T("UIGHUR"),
1581 _T("UKRAINIAN"),
1582 _T("URDU"),
1583 _T("URDU_INDIA"),
1584 _T("URDU_PAKISTAN"),
1585 _T("UZBEK"),
1586 _T("UZBEK_CYRILLIC"),
1587 _T("UZBEK_LATIN"),
1588 _T("VIETNAMESE"),
1589 _T("VOLAPUK"),
1590 _T("WELSH"),
1591 _T("WOLOF"),
1592 _T("XHOSA"),
1593 _T("YIDDISH"),
1594 _T("YORUBA"),
1595 _T("ZHUANG"),
1596 _T("ZULU"),
1597 };
1598
1599 if ( (size_t)lang < WXSIZEOF(languageNames) )
1600 return languageNames[lang];
1601 else
1602 return _T("INVALID");
1603 }
1604
1605 static void TestDefaultLang()
1606 {
1607 wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
1608
1609 static const wxChar *langStrings[] =
1610 {
1611 NULL, // system default
1612 _T("C"),
1613 _T("fr"),
1614 _T("fr_FR"),
1615 _T("en"),
1616 _T("en_GB"),
1617 _T("en_US"),
1618 _T("de_DE.iso88591"),
1619 _T("german"),
1620 _T("?"), // invalid lang spec
1621 _T("klingonese"), // I bet on some systems it does exist...
1622 };
1623
1624 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1625 wxLocale::GetSystemEncodingName().c_str(),
1626 wxLocale::GetSystemEncoding());
1627
1628 for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1629 {
1630 const wxChar *langStr = langStrings[n];
1631 if ( langStr )
1632 {
1633 // FIXME: this doesn't do anything at all under Windows, we need
1634 // to create a new wxLocale!
1635 wxSetEnv(_T("LC_ALL"), langStr);
1636 }
1637
1638 int lang = gs_localeDefault.GetSystemLanguage();
1639 wxPrintf(_T("Locale for '%s' is %s.\n"),
1640 langStr ? langStr : _T("system default"), GetLangName(lang));
1641 }
1642 }
1643
1644 #endif // TEST_LOCALE
1645
1646 // ----------------------------------------------------------------------------
1647 // MIME types
1648 // ----------------------------------------------------------------------------
1649
1650 #ifdef TEST_MIME
1651
1652 #include "wx/mimetype.h"
1653
1654 static void TestMimeEnum()
1655 {
1656 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1657
1658 wxArrayString mimetypes;
1659
1660 size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1661
1662 wxPrintf(_T("*** All %u known filetypes: ***\n"), count);
1663
1664 wxArrayString exts;
1665 wxString desc;
1666
1667 for ( size_t n = 0; n < count; n++ )
1668 {
1669 wxFileType *filetype =
1670 wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1671 if ( !filetype )
1672 {
1673 wxPrintf(_T("nothing known about the filetype '%s'!\n"),
1674 mimetypes[n].c_str());
1675 continue;
1676 }
1677
1678 filetype->GetDescription(&desc);
1679 filetype->GetExtensions(exts);
1680
1681 filetype->GetIcon(NULL);
1682
1683 wxString extsAll;
1684 for ( size_t e = 0; e < exts.GetCount(); e++ )
1685 {
1686 if ( e > 0 )
1687 extsAll << _T(", ");
1688 extsAll += exts[e];
1689 }
1690
1691 wxPrintf(_T("\t%s: %s (%s)\n"),
1692 mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1693 }
1694
1695 wxPuts(wxEmptyString);
1696 }
1697
1698 static void TestMimeOverride()
1699 {
1700 wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1701
1702 static const wxChar *mailcap = _T("/tmp/mailcap");
1703 static const wxChar *mimetypes = _T("/tmp/mime.types");
1704
1705 if ( wxFile::Exists(mailcap) )
1706 wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1707 mailcap,
1708 wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
1709 else
1710 wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1711 mailcap);
1712
1713 if ( wxFile::Exists(mimetypes) )
1714 wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1715 mimetypes,
1716 wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
1717 else
1718 wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1719 mimetypes);
1720
1721 wxPuts(wxEmptyString);
1722 }
1723
1724 static void TestMimeFilename()
1725 {
1726 wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1727
1728 static const wxChar *filenames[] =
1729 {
1730 _T("readme.txt"),
1731 _T("document.pdf"),
1732 _T("image.gif"),
1733 _T("picture.jpeg"),
1734 };
1735
1736 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1737 {
1738 const wxString fname = filenames[n];
1739 wxString ext = fname.AfterLast(_T('.'));
1740 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1741 if ( !ft )
1742 {
1743 wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1744 }
1745 else
1746 {
1747 wxString desc;
1748 if ( !ft->GetDescription(&desc) )
1749 desc = _T("<no description>");
1750
1751 wxString cmd;
1752 if ( !ft->GetOpenCommand(&cmd,
1753 wxFileType::MessageParameters(fname, wxEmptyString)) )
1754 cmd = _T("<no command available>");
1755 else
1756 cmd = wxString(_T('"')) + cmd + _T('"');
1757
1758 wxPrintf(_T("To open %s (%s) do %s.\n"),
1759 fname.c_str(), desc.c_str(), cmd.c_str());
1760
1761 delete ft;
1762 }
1763 }
1764
1765 wxPuts(wxEmptyString);
1766 }
1767
1768 static void TestMimeAssociate()
1769 {
1770 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1771
1772 wxFileTypeInfo ftInfo(
1773 _T("application/x-xyz"),
1774 _T("xyzview '%s'"), // open cmd
1775 _T(""), // print cmd
1776 _T("XYZ File"), // description
1777 _T(".xyz"), // extensions
1778 NULL // end of extensions
1779 );
1780 ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
1781
1782 wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1783 if ( !ft )
1784 {
1785 wxPuts(_T("ERROR: failed to create association!"));
1786 }
1787 else
1788 {
1789 // TODO: read it back
1790 delete ft;
1791 }
1792
1793 wxPuts(wxEmptyString);
1794 }
1795
1796 #endif // TEST_MIME
1797
1798 // ----------------------------------------------------------------------------
1799 // misc information functions
1800 // ----------------------------------------------------------------------------
1801
1802 #ifdef TEST_INFO_FUNCTIONS
1803
1804 #include "wx/utils.h"
1805
1806 static void TestDiskInfo()
1807 {
1808 wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
1809
1810 for ( ;; )
1811 {
1812 wxChar pathname[128];
1813 wxPrintf(_T("\nEnter a directory name: "));
1814 if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
1815 break;
1816
1817 // kill the last '\n'
1818 pathname[wxStrlen(pathname) - 1] = 0;
1819
1820 wxLongLong total, free;
1821 if ( !wxGetDiskSpace(pathname, &total, &free) )
1822 {
1823 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1824 }
1825 else
1826 {
1827 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1828 (total / 1024).ToString().c_str(),
1829 (free / 1024).ToString().c_str(),
1830 pathname);
1831 }
1832 }
1833 }
1834
1835 static void TestOsInfo()
1836 {
1837 wxPuts(_T("*** Testing OS info functions ***\n"));
1838
1839 int major, minor;
1840 wxGetOsVersion(&major, &minor);
1841 wxPrintf(_T("Running under: %s, version %d.%d\n"),
1842 wxGetOsDescription().c_str(), major, minor);
1843
1844 wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory());
1845
1846 wxPrintf(_T("Host name is %s (%s).\n"),
1847 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1848
1849 wxPuts(wxEmptyString);
1850 }
1851
1852 static void TestUserInfo()
1853 {
1854 wxPuts(_T("*** Testing user info functions ***\n"));
1855
1856 wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
1857 wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
1858 wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
1859 wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
1860
1861 wxPuts(wxEmptyString);
1862 }
1863
1864 #endif // TEST_INFO_FUNCTIONS
1865
1866 // ----------------------------------------------------------------------------
1867 // path list
1868 // ----------------------------------------------------------------------------
1869
1870 #ifdef TEST_PATHLIST
1871
1872 #ifdef __UNIX__
1873 #define CMD_IN_PATH _T("ls")
1874 #else
1875 #define CMD_IN_PATH _T("command.com")
1876 #endif
1877
1878 static void TestPathList()
1879 {
1880 wxPuts(_T("*** Testing wxPathList ***\n"));
1881
1882 wxPathList pathlist;
1883 pathlist.AddEnvList(_T("PATH"));
1884 wxString path = pathlist.FindValidPath(CMD_IN_PATH);
1885 if ( path.empty() )
1886 {
1887 wxPrintf(_T("ERROR: command not found in the path.\n"));
1888 }
1889 else
1890 {
1891 wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
1892 }
1893 }
1894
1895 #endif // TEST_PATHLIST
1896
1897 // ----------------------------------------------------------------------------
1898 // regular expressions
1899 // ----------------------------------------------------------------------------
1900
1901 #ifdef TEST_REGEX
1902
1903 #include "wx/regex.h"
1904
1905 static void TestRegExInteractive()
1906 {
1907 wxPuts(_T("*** Testing RE interactively ***"));
1908
1909 for ( ;; )
1910 {
1911 wxChar pattern[128];
1912 wxPrintf(_T("\nEnter a pattern: "));
1913 if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
1914 break;
1915
1916 // kill the last '\n'
1917 pattern[wxStrlen(pattern) - 1] = 0;
1918
1919 wxRegEx re;
1920 if ( !re.Compile(pattern) )
1921 {
1922 continue;
1923 }
1924
1925 wxChar text[128];
1926 for ( ;; )
1927 {
1928 wxPrintf(_T("Enter text to match: "));
1929 if ( !wxFgets(text, WXSIZEOF(text), stdin) )
1930 break;
1931
1932 // kill the last '\n'
1933 text[wxStrlen(text) - 1] = 0;
1934
1935 if ( !re.Matches(text) )
1936 {
1937 wxPrintf(_T("No match.\n"));
1938 }
1939 else
1940 {
1941 wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
1942
1943 size_t start, len;
1944 for ( size_t n = 1; ; n++ )
1945 {
1946 if ( !re.GetMatch(&start, &len, n) )
1947 {
1948 break;
1949 }
1950
1951 wxPrintf(_T("Subexpr %u matched '%s'\n"),
1952 n, wxString(text + start, len).c_str());
1953 }
1954 }
1955 }
1956 }
1957 }
1958
1959 #endif // TEST_REGEX
1960
1961 // ----------------------------------------------------------------------------
1962 // database
1963 // ----------------------------------------------------------------------------
1964
1965 #if !wxUSE_ODBC
1966 #undef TEST_ODBC
1967 #endif
1968
1969 #ifdef TEST_ODBC
1970
1971 #include <wx/db.h>
1972
1973 static void TestDbOpen()
1974 {
1975 HENV henv;
1976 wxDb db(henv);
1977 }
1978
1979 #endif // TEST_ODBC
1980
1981 // ----------------------------------------------------------------------------
1982 // printf() tests
1983 // ----------------------------------------------------------------------------
1984
1985 /*
1986 NB: this stuff was taken from the glibc test suite and modified to build
1987 in wxWidgets: if I read the copyright below properly, this shouldn't
1988 be a problem
1989 */
1990
1991 #ifdef TEST_PRINTF
1992
1993 #ifdef wxTEST_PRINTF
1994 // use our functions from wxchar.cpp
1995 #undef wxPrintf
1996 #undef wxSprintf
1997
1998 // NB: do _not_ use ATTRIBUTE_PRINTF here, we have some invalid formats
1999 // in the tests below
2000 int wxPrintf( const wxChar *format, ... );
2001 int wxSprintf( wxChar *str, const wxChar *format, ... );
2002 #endif
2003
2004 #include "wx/longlong.h"
2005
2006 #include <float.h>
2007
2008 static void rfg1 (void);
2009 static void rfg2 (void);
2010
2011
2012 static void
2013 fmtchk (const wxChar *fmt)
2014 {
2015 (void) wxPrintf(_T("%s:\t`"), fmt);
2016 (void) wxPrintf(fmt, 0x12);
2017 (void) wxPrintf(_T("'\n"));
2018 }
2019
2020 static void
2021 fmtst1chk (const wxChar *fmt)
2022 {
2023 (void) wxPrintf(_T("%s:\t`"), fmt);
2024 (void) wxPrintf(fmt, 4, 0x12);
2025 (void) wxPrintf(_T("'\n"));
2026 }
2027
2028 static void
2029 fmtst2chk (const wxChar *fmt)
2030 {
2031 (void) wxPrintf(_T("%s:\t`"), fmt);
2032 (void) wxPrintf(fmt, 4, 4, 0x12);
2033 (void) wxPrintf(_T("'\n"));
2034 }
2035
2036 /* This page is covered by the following copyright: */
2037
2038 /* (C) Copyright C E Chew
2039 *
2040 * Feel free to copy, use and distribute this software provided:
2041 *
2042 * 1. you do not pretend that you wrote it
2043 * 2. you leave this copyright notice intact.
2044 */
2045
2046 /*
2047 * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
2048 */
2049
2050 #define DEC -123
2051 #define INT 255
2052 #define UNS (~0)
2053
2054 /* Formatted Output Test
2055 *
2056 * This exercises the output formatting code.
2057 */
2058
2059 wxChar *PointerNull = NULL;
2060
2061 static void
2062 fp_test (void)
2063 {
2064 int i, j, k, l;
2065 wxChar buf[7];
2066 wxChar *prefix = buf;
2067 wxChar tp[20];
2068
2069 wxPuts(_T("\nFormatted output test"));
2070 wxPrintf(_T("prefix 6d 6o 6x 6X 6u\n"));
2071 wxStrcpy(prefix, _T("%"));
2072 for (i = 0; i < 2; i++) {
2073 for (j = 0; j < 2; j++) {
2074 for (k = 0; k < 2; k++) {
2075 for (l = 0; l < 2; l++) {
2076 wxStrcpy(prefix, _T("%"));
2077 if (i == 0) wxStrcat(prefix, _T("-"));
2078 if (j == 0) wxStrcat(prefix, _T("+"));
2079 if (k == 0) wxStrcat(prefix, _T("#"));
2080 if (l == 0) wxStrcat(prefix, _T("0"));
2081 wxPrintf(_T("%5s |"), prefix);
2082 wxStrcpy(tp, prefix);
2083 wxStrcat(tp, _T("6d |"));
2084 wxPrintf(tp, DEC);
2085 wxStrcpy(tp, prefix);
2086 wxStrcat(tp, _T("6o |"));
2087 wxPrintf(tp, INT);
2088 wxStrcpy(tp, prefix);
2089 wxStrcat(tp, _T("6x |"));
2090 wxPrintf(tp, INT);
2091 wxStrcpy(tp, prefix);
2092 wxStrcat(tp, _T("6X |"));
2093 wxPrintf(tp, INT);
2094 wxStrcpy(tp, prefix);
2095 wxStrcat(tp, _T("6u |"));
2096 wxPrintf(tp, UNS);
2097 wxPrintf(_T("\n"));
2098 }
2099 }
2100 }
2101 }
2102 wxPrintf(_T("%10s\n"), PointerNull);
2103 wxPrintf(_T("%-10s\n"), PointerNull);
2104 }
2105
2106 static void TestPrintf()
2107 {
2108 static wxChar shortstr[] = _T("Hi, Z.");
2109 static wxChar longstr[] = _T("Good morning, Doctor Chandra. This is Hal. \
2110 I am ready for my first lesson today.");
2111 int result = 0;
2112 wxString test_format;
2113
2114 fmtchk(_T("%.4x"));
2115 fmtchk(_T("%04x"));
2116 fmtchk(_T("%4.4x"));
2117 fmtchk(_T("%04.4x"));
2118 fmtchk(_T("%4.3x"));
2119 fmtchk(_T("%04.3x"));
2120
2121 fmtst1chk(_T("%.*x"));
2122 fmtst1chk(_T("%0*x"));
2123 fmtst2chk(_T("%*.*x"));
2124 fmtst2chk(_T("%0*.*x"));
2125
2126 wxString bad_format = _T("bad format:\t\"%b\"\n");
2127 wxPrintf(bad_format.c_str());
2128 wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
2129
2130 wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
2131 wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
2132 wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
2133 wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
2134 wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
2135 wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
2136 wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
2137 test_format = _T("left-adjusted ZLDN:\t\"%-010ld\"\n");
2138 wxPrintf(test_format.c_str(), -123456);
2139 wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
2140 wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
2141
2142 test_format = _T("zero-padded string:\t\"%010s\"\n");
2143 wxPrintf(test_format.c_str(), shortstr);
2144 test_format = _T("left-adjusted Z string:\t\"%-010s\"\n");
2145 wxPrintf(test_format.c_str(), shortstr);
2146 wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
2147 wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
2148 wxPrintf(_T("null string:\t\"%s\"\n"), PointerNull);
2149 wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr);
2150
2151 wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
2152 wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
2153 wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
2154 wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20);
2155 wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
2156 wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
2157 wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
2158 wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
2159 wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
2160 wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
2161 wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
2162 wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20);
2163
2164 wxPrintf (_T(" %6.5f\n"), .099999999860301614);
2165 wxPrintf (_T(" %6.5f\n"), .1);
2166 wxPrintf (_T("x%5.4fx\n"), .5);
2167
2168 wxPrintf (_T("%#03x\n"), 1);
2169
2170 //wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
2171
2172 {
2173 double d = FLT_MIN;
2174 int niter = 17;
2175
2176 while (niter-- != 0)
2177 wxPrintf (_T("%.17e\n"), d / 2);
2178 fflush (stdout);
2179 }
2180
2181 #ifndef __WATCOMC__
2182 // Open Watcom cause compiler error here
2183 // Error! E173: col(24) floating-point constant too small to represent
2184 wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
2185 #endif
2186
2187 #define FORMAT _T("|%12.4f|%12.4e|%12.4g|\n")
2188 wxPrintf (FORMAT, 0.0, 0.0, 0.0);
2189 wxPrintf (FORMAT, 1.0, 1.0, 1.0);
2190 wxPrintf (FORMAT, -1.0, -1.0, -1.0);
2191 wxPrintf (FORMAT, 100.0, 100.0, 100.0);
2192 wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
2193 wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
2194 wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
2195 wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
2196 wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
2197 #undef FORMAT
2198
2199 {
2200 wxChar buf[20];
2201 int rc = wxSnprintf (buf, WXSIZEOF(buf), _T("%30s"), _T("foo"));
2202
2203 wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
2204 rc, WXSIZEOF(buf), buf);
2205 #if 0
2206 wxChar buf2[512];
2207 wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
2208 wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
2209 #endif
2210 }
2211
2212 fp_test ();
2213
2214 wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
2215 wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
2216 wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
2217 wxPrintf (_T("%g should be 123.456\n"), 123.456);
2218 wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
2219 wxPrintf (_T("%g should be 10\n"), 10.0);
2220 wxPrintf (_T("%g should be 0.02\n"), 0.02);
2221
2222 {
2223 double x=1.0;
2224 wxPrintf(_T("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
2225 }
2226
2227 {
2228 wxChar buf[200];
2229
2230 wxSprintf(buf,_T("%*s%*s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
2231
2232 result |= wxStrcmp (buf,
2233 _T("onetwo three "));
2234
2235 wxPuts (result != 0 ? _T("Test failed!") : _T("Test ok."));
2236 }
2237
2238 #ifdef wxLongLong_t
2239 {
2240 wxChar buf[200];
2241
2242 wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
2243 #if 0
2244 // for some reason below line fails under Borland
2245 wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
2246 #endif
2247
2248 if (wxStrcmp (buf, _T("40000000000")) != 0)
2249 {
2250 result = 1;
2251 wxPuts (_T("\tFAILED"));
2252 }
2253 wxUnusedVar(result);
2254 wxPuts (wxEmptyString);
2255 }
2256 #endif // wxLongLong_t
2257
2258 wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
2259 wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
2260
2261 wxPuts (_T("--- Should be no further output. ---"));
2262 rfg1 ();
2263 rfg2 ();
2264
2265 #if 0
2266 {
2267 wxChar bytes[7];
2268 wxChar buf[20];
2269
2270 memset (bytes, '\xff', sizeof bytes);
2271 wxSprintf (buf, _T("foo%hhn\n"), &bytes[3]);
2272 if (bytes[0] != '\xff' || bytes[1] != '\xff' || bytes[2] != '\xff'
2273 || bytes[4] != '\xff' || bytes[5] != '\xff' || bytes[6] != '\xff')
2274 {
2275 wxPuts (_T("%hhn overwrite more bytes"));
2276 result = 1;
2277 }
2278 if (bytes[3] != 3)
2279 {
2280 wxPuts (_T("%hhn wrote incorrect value"));
2281 result = 1;
2282 }
2283 }
2284 #endif
2285 }
2286
2287 static void
2288 rfg1 (void)
2289 {
2290 wxChar buf[100];
2291
2292 wxSprintf (buf, _T("%5.s"), _T("xyz"));
2293 if (wxStrcmp (buf, _T(" ")) != 0)
2294 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" "));
2295 wxSprintf (buf, _T("%5.f"), 33.3);
2296 if (wxStrcmp (buf, _T(" 33")) != 0)
2297 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 33"));
2298 wxSprintf (buf, _T("%8.e"), 33.3e7);
2299 if (wxStrcmp (buf, _T(" 3e+08")) != 0)
2300 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3e+08"));
2301 wxSprintf (buf, _T("%8.E"), 33.3e7);
2302 if (wxStrcmp (buf, _T(" 3E+08")) != 0)
2303 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3E+08"));
2304 wxSprintf (buf, _T("%.g"), 33.3);
2305 if (wxStrcmp (buf, _T("3e+01")) != 0)
2306 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3e+01"));
2307 wxSprintf (buf, _T("%.G"), 33.3);
2308 if (wxStrcmp (buf, _T("3E+01")) != 0)
2309 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3E+01"));
2310 }
2311
2312 static void
2313 rfg2 (void)
2314 {
2315 int prec;
2316 wxChar buf[100];
2317 wxString test_format;
2318
2319 prec = 0;
2320 wxSprintf (buf, _T("%.*g"), prec, 3.3);
2321 if (wxStrcmp (buf, _T("3")) != 0)
2322 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
2323 prec = 0;
2324 wxSprintf (buf, _T("%.*G"), prec, 3.3);
2325 if (wxStrcmp (buf, _T("3")) != 0)
2326 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
2327 prec = 0;
2328 wxSprintf (buf, _T("%7.*G"), prec, 3.33);
2329 if (wxStrcmp (buf, _T(" 3")) != 0)
2330 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3"));
2331 prec = 3;
2332 test_format = _T("%04.*o");
2333 wxSprintf (buf, test_format.c_str(), prec, 33);
2334 if (wxStrcmp (buf, _T(" 041")) != 0)
2335 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
2336 prec = 7;
2337 test_format = _T("%09.*u");
2338 wxSprintf (buf, test_format.c_str(), prec, 33);
2339 if (wxStrcmp (buf, _T(" 0000033")) != 0)
2340 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 0000033"));
2341 prec = 3;
2342 test_format = _T("%04.*x");
2343 wxSprintf (buf, test_format.c_str(), prec, 33);
2344 if (wxStrcmp (buf, _T(" 021")) != 0)
2345 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2346 prec = 3;
2347 test_format = _T("%04.*X");
2348 wxSprintf (buf, test_format.c_str(), prec, 33);
2349 if (wxStrcmp (buf, _T(" 021")) != 0)
2350 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
2351 }
2352
2353 #endif // TEST_PRINTF
2354
2355 // ----------------------------------------------------------------------------
2356 // registry and related stuff
2357 // ----------------------------------------------------------------------------
2358
2359 // this is for MSW only
2360 #ifndef __WXMSW__
2361 #undef TEST_REGCONF
2362 #undef TEST_REGISTRY
2363 #endif
2364
2365 #ifdef TEST_REGCONF
2366
2367 #include "wx/confbase.h"
2368 #include "wx/msw/regconf.h"
2369
2370 #if 0
2371 static void TestRegConfWrite()
2372 {
2373 wxConfig *config = new wxConfig(_T("myapp"));
2374 config->SetPath(_T("/group1"));
2375 config->Write(_T("entry1"), _T("foo"));
2376 config->SetPath(_T("/group2"));
2377 config->Write(_T("entry1"), _T("bar"));
2378 }
2379 #endif
2380
2381 static void TestRegConfRead()
2382 {
2383 wxConfig *config = new wxConfig(_T("myapp"));
2384
2385 wxString str;
2386 long dummy;
2387 config->SetPath(_T("/"));
2388 wxPuts(_T("Enumerating / subgroups:"));
2389 bool bCont = config->GetFirstGroup(str, dummy);
2390 while(bCont)
2391 {
2392 wxPuts(str);
2393 bCont = config->GetNextGroup(str, dummy);
2394 }
2395 }
2396
2397 #endif // TEST_REGCONF
2398
2399 #ifdef TEST_REGISTRY
2400
2401 #include "wx/msw/registry.h"
2402
2403 // I chose this one because I liked its name, but it probably only exists under
2404 // NT
2405 static const wxChar *TESTKEY =
2406 _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2407
2408 static void TestRegistryRead()
2409 {
2410 wxPuts(_T("*** testing registry reading ***"));
2411
2412 wxRegKey key(TESTKEY);
2413 wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
2414 if ( !key.Open() )
2415 {
2416 wxPuts(_T("ERROR: test key can't be opened, aborting test."));
2417
2418 return;
2419 }
2420
2421 size_t nSubKeys, nValues;
2422 if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
2423 {
2424 wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
2425 }
2426
2427 wxPrintf(_T("Enumerating values:\n"));
2428
2429 long dummy;
2430 wxString value;
2431 bool cont = key.GetFirstValue(value, dummy);
2432 while ( cont )
2433 {
2434 wxPrintf(_T("Value '%s': type "), value.c_str());
2435 switch ( key.GetValueType(value) )
2436 {
2437 case wxRegKey::Type_None: wxPrintf(_T("ERROR (none)")); break;
2438 case wxRegKey::Type_String: wxPrintf(_T("SZ")); break;
2439 case wxRegKey::Type_Expand_String: wxPrintf(_T("EXPAND_SZ")); break;
2440 case wxRegKey::Type_Binary: wxPrintf(_T("BINARY")); break;
2441 case wxRegKey::Type_Dword: wxPrintf(_T("DWORD")); break;
2442 case wxRegKey::Type_Multi_String: wxPrintf(_T("MULTI_SZ")); break;
2443 default: wxPrintf(_T("other (unknown)")); break;
2444 }
2445
2446 wxPrintf(_T(", value = "));
2447 if ( key.IsNumericValue(value) )
2448 {
2449 long val;
2450 key.QueryValue(value, &val);
2451 wxPrintf(_T("%ld"), val);
2452 }
2453 else // string
2454 {
2455 wxString val;
2456 key.QueryValue(value, val);
2457 wxPrintf(_T("'%s'"), val.c_str());
2458
2459 key.QueryRawValue(value, val);
2460 wxPrintf(_T(" (raw value '%s')"), val.c_str());
2461 }
2462
2463 wxPutchar('\n');
2464
2465 cont = key.GetNextValue(value, dummy);
2466 }
2467 }
2468
2469 static void TestRegistryAssociation()
2470 {
2471 /*
2472 The second call to deleteself genertaes an error message, with a
2473 messagebox saying .flo is crucial to system operation, while the .ddf
2474 call also fails, but with no error message
2475 */
2476
2477 wxRegKey key;
2478
2479 key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2480 key.Create();
2481 key = _T("ddxf_auto_file") ;
2482 key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2483 key.Create();
2484 key = _T("ddxf_auto_file") ;
2485 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2486 key.Create();
2487 key = _T("program,0") ;
2488 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2489 key.Create();
2490 key = _T("program \"%1\"") ;
2491
2492 key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2493 key.DeleteSelf();
2494 key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2495 key.DeleteSelf();
2496 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2497 key.DeleteSelf();
2498 key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2499 key.DeleteSelf();
2500 }
2501
2502 #endif // TEST_REGISTRY
2503
2504 // ----------------------------------------------------------------------------
2505 // scope guard
2506 // ----------------------------------------------------------------------------
2507
2508 #ifdef TEST_SCOPEGUARD
2509
2510 #include "wx/scopeguard.h"
2511
2512 static void function0() { puts("function0()"); }
2513 static void function1(int n) { printf("function1(%d)\n", n); }
2514 static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
2515
2516 struct Object
2517 {
2518 void method0() { printf("method0()\n"); }
2519 void method1(int n) { printf("method1(%d)\n", n); }
2520 void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
2521 };
2522
2523 static void TestScopeGuard()
2524 {
2525 wxON_BLOCK_EXIT0(function0);
2526 wxON_BLOCK_EXIT1(function1, 17);
2527 wxON_BLOCK_EXIT2(function2, 3.14, 'p');
2528
2529 Object obj;
2530 wxON_BLOCK_EXIT_OBJ0(obj, &Object::method0);
2531 wxON_BLOCK_EXIT_OBJ1(obj, &Object::method1, 7);
2532 wxON_BLOCK_EXIT_OBJ2(obj, &Object::method2, 2.71, 'e');
2533
2534 wxScopeGuard dismissed = wxMakeGuard(function0);
2535 dismissed.Dismiss();
2536 }
2537
2538 #endif
2539
2540 // ----------------------------------------------------------------------------
2541 // sockets
2542 // ----------------------------------------------------------------------------
2543
2544 #ifdef TEST_SOCKETS
2545
2546 #include "wx/socket.h"
2547 #include "wx/protocol/protocol.h"
2548 #include "wx/protocol/http.h"
2549
2550 static void TestSocketServer()
2551 {
2552 wxPuts(_T("*** Testing wxSocketServer ***\n"));
2553
2554 static const int PORT = 3000;
2555
2556 wxIPV4address addr;
2557 addr.Service(PORT);
2558
2559 wxSocketServer *server = new wxSocketServer(addr);
2560 if ( !server->Ok() )
2561 {
2562 wxPuts(_T("ERROR: failed to bind"));
2563
2564 return;
2565 }
2566
2567 bool quit = false;
2568 while ( !quit )
2569 {
2570 wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
2571
2572 wxSocketBase *socket = server->Accept();
2573 if ( !socket )
2574 {
2575 wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
2576 break;
2577 }
2578
2579 wxPuts(_T("Server: got a client."));
2580
2581 server->SetTimeout(60); // 1 min
2582
2583 bool close = false;
2584 while ( !close && socket->IsConnected() )
2585 {
2586 wxString s;
2587 wxChar ch = _T('\0');
2588 for ( ;; )
2589 {
2590 if ( socket->Read(&ch, sizeof(ch)).Error() )
2591 {
2592 // don't log error if the client just close the connection
2593 if ( socket->IsConnected() )
2594 {
2595 wxPuts(_T("ERROR: in wxSocket::Read."));
2596 }
2597
2598 break;
2599 }
2600
2601 if ( ch == '\r' )
2602 continue;
2603
2604 if ( ch == '\n' )
2605 break;
2606
2607 s += ch;
2608 }
2609
2610 if ( ch != '\n' )
2611 {
2612 break;
2613 }
2614
2615 wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
2616 if ( s == _T("close") )
2617 {
2618 wxPuts(_T("Closing connection"));
2619
2620 close = true;
2621 }
2622 else if ( s == _T("quit") )
2623 {
2624 close =
2625 quit = true;
2626
2627 wxPuts(_T("Shutting down the server"));
2628 }
2629 else // not a special command
2630 {
2631 socket->Write(s.MakeUpper().c_str(), s.length());
2632 socket->Write("\r\n", 2);
2633 wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
2634 }
2635 }
2636
2637 if ( !close )
2638 {
2639 wxPuts(_T("Server: lost a client unexpectedly."));
2640 }
2641
2642 socket->Destroy();
2643 }
2644
2645 // same as "delete server" but is consistent with GUI programs
2646 server->Destroy();
2647 }
2648
2649 static void TestSocketClient()
2650 {
2651 wxPuts(_T("*** Testing wxSocketClient ***\n"));
2652
2653 static const wxChar *hostname = _T("www.wxwidgets.org");
2654
2655 wxIPV4address addr;
2656 addr.Hostname(hostname);
2657 addr.Service(80);
2658
2659 wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
2660
2661 wxSocketClient client;
2662 if ( !client.Connect(addr) )
2663 {
2664 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2665 }
2666 else
2667 {
2668 wxPrintf(_T("--- Connected to %s:%u...\n"),
2669 addr.Hostname().c_str(), addr.Service());
2670
2671 wxChar buf[8192];
2672
2673 // could use simply "GET" here I suppose
2674 wxString cmdGet =
2675 wxString::Format(_T("GET http://%s/\r\n"), hostname);
2676 client.Write(cmdGet, cmdGet.length());
2677 wxPrintf(_T("--- Sent command '%s' to the server\n"),
2678 MakePrintable(cmdGet).c_str());
2679 client.Read(buf, WXSIZEOF(buf));
2680 wxPrintf(_T("--- Server replied:\n%s"), buf);
2681 }
2682 }
2683
2684 #endif // TEST_SOCKETS
2685
2686 // ----------------------------------------------------------------------------
2687 // FTP
2688 // ----------------------------------------------------------------------------
2689
2690 #ifdef TEST_FTP
2691
2692 #include "wx/protocol/ftp.h"
2693
2694 static wxFTP ftp;
2695
2696 #define FTP_ANONYMOUS
2697
2698 #ifdef FTP_ANONYMOUS
2699 static const wxChar *directory = _T("/pub");
2700 static const wxChar *filename = _T("welcome.msg");
2701 #else
2702 static const wxChar *directory = _T("/etc");
2703 static const wxChar *filename = _T("issue");
2704 #endif
2705
2706 static bool TestFtpConnect()
2707 {
2708 wxPuts(_T("*** Testing FTP connect ***"));
2709
2710 #ifdef FTP_ANONYMOUS
2711 static const wxChar *hostname = _T("ftp.wxwidgets.org");
2712
2713 wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
2714 #else // !FTP_ANONYMOUS
2715 static const wxChar *hostname = "localhost";
2716
2717 wxChar user[256];
2718 wxFgets(user, WXSIZEOF(user), stdin);
2719 user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
2720 ftp.SetUser(user);
2721
2722 wxChar password[256];
2723 wxPrintf(_T("Password for %s: "), password);
2724 wxFgets(password, WXSIZEOF(password), stdin);
2725 password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
2726 ftp.SetPassword(password);
2727
2728 wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
2729 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2730
2731 if ( !ftp.Connect(hostname) )
2732 {
2733 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2734
2735 return false;
2736 }
2737 else
2738 {
2739 wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
2740 hostname, ftp.Pwd().c_str());
2741 ftp.Close();
2742 }
2743
2744 return true;
2745 }
2746
2747 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2748 static void TestFtpWuFtpd()
2749 {
2750 wxFTP ftp;
2751 static const wxChar *hostname = _T("ftp.eudora.com");
2752 if ( !ftp.Connect(hostname) )
2753 {
2754 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
2755 }
2756 else
2757 {
2758 static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
2759 wxInputStream *in = ftp.GetInputStream(filename);
2760 if ( !in )
2761 {
2762 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
2763 }
2764 else
2765 {
2766 size_t size = in->GetSize();
2767 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
2768
2769 wxChar *data = new wxChar[size];
2770 if ( !in->Read(data, size) )
2771 {
2772 wxPuts(_T("ERROR: read error"));
2773 }
2774 else
2775 {
2776 wxPrintf(_T("Successfully retrieved the file.\n"));
2777 }
2778
2779 delete [] data;
2780 delete in;
2781 }
2782 }
2783 }
2784
2785 static void TestFtpList()
2786 {
2787 wxPuts(_T("*** Testing wxFTP file listing ***\n"));
2788
2789 // test CWD
2790 if ( !ftp.ChDir(directory) )
2791 {
2792 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
2793 }
2794
2795 wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
2796
2797 // test NLIST and LIST
2798 wxArrayString files;
2799 if ( !ftp.GetFilesList(files) )
2800 {
2801 wxPuts(_T("ERROR: failed to get NLIST of files"));
2802 }
2803 else
2804 {
2805 wxPrintf(_T("Brief list of files under '%s':\n"), ftp.Pwd().c_str());
2806 size_t count = files.GetCount();
2807 for ( size_t n = 0; n < count; n++ )
2808 {
2809 wxPrintf(_T("\t%s\n"), files[n].c_str());
2810 }
2811 wxPuts(_T("End of the file list"));
2812 }
2813
2814 if ( !ftp.GetDirList(files) )
2815 {
2816 wxPuts(_T("ERROR: failed to get LIST of files"));
2817 }
2818 else
2819 {
2820 wxPrintf(_T("Detailed list of files under '%s':\n"), ftp.Pwd().c_str());
2821 size_t count = files.GetCount();
2822 for ( size_t n = 0; n < count; n++ )
2823 {
2824 wxPrintf(_T("\t%s\n"), files[n].c_str());
2825 }
2826 wxPuts(_T("End of the file list"));
2827 }
2828
2829 if ( !ftp.ChDir(_T("..")) )
2830 {
2831 wxPuts(_T("ERROR: failed to cd to .."));
2832 }
2833
2834 wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
2835 }
2836
2837 static void TestFtpDownload()
2838 {
2839 wxPuts(_T("*** Testing wxFTP download ***\n"));
2840
2841 // test RETR
2842 wxInputStream *in = ftp.GetInputStream(filename);
2843 if ( !in )
2844 {
2845 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
2846 }
2847 else
2848 {
2849 size_t size = in->GetSize();
2850 wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
2851 fflush(stdout);
2852
2853 wxChar *data = new wxChar[size];
2854 if ( !in->Read(data, size) )
2855 {
2856 wxPuts(_T("ERROR: read error"));
2857 }
2858 else
2859 {
2860 wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
2861 }
2862
2863 delete [] data;
2864 delete in;
2865 }
2866 }
2867
2868 static void TestFtpFileSize()
2869 {
2870 wxPuts(_T("*** Testing FTP SIZE command ***"));
2871
2872 if ( !ftp.ChDir(directory) )
2873 {
2874 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
2875 }
2876
2877 wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
2878
2879 if ( ftp.FileExists(filename) )
2880 {
2881 int size = ftp.GetFileSize(filename);
2882 if ( size == -1 )
2883 wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
2884 else
2885 wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
2886 }
2887 else
2888 {
2889 wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
2890 }
2891 }
2892
2893 static void TestFtpMisc()
2894 {
2895 wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
2896
2897 if ( ftp.SendCommand(_T("STAT")) != '2' )
2898 {
2899 wxPuts(_T("ERROR: STAT failed"));
2900 }
2901 else
2902 {
2903 wxPrintf(_T("STAT returned:\n\n%s\n"), ftp.GetLastResult().c_str());
2904 }
2905
2906 if ( ftp.SendCommand(_T("HELP SITE")) != '2' )
2907 {
2908 wxPuts(_T("ERROR: HELP SITE failed"));
2909 }
2910 else
2911 {
2912 wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
2913 ftp.GetLastResult().c_str());
2914 }
2915 }
2916
2917 static void TestFtpInteractive()
2918 {
2919 wxPuts(_T("\n*** Interactive wxFTP test ***"));
2920
2921 wxChar buf[128];
2922
2923 for ( ;; )
2924 {
2925 wxPrintf(_T("Enter FTP command: "));
2926 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
2927 break;
2928
2929 // kill the last '\n'
2930 buf[wxStrlen(buf) - 1] = 0;
2931
2932 // special handling of LIST and NLST as they require data connection
2933 wxString start(buf, 4);
2934 start.MakeUpper();
2935 if ( start == _T("LIST") || start == _T("NLST") )
2936 {
2937 wxString wildcard;
2938 if ( wxStrlen(buf) > 4 )
2939 wildcard = buf + 5;
2940
2941 wxArrayString files;
2942 if ( !ftp.GetList(files, wildcard, start == _T("LIST")) )
2943 {
2944 wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
2945 }
2946 else
2947 {
2948 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
2949 start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
2950 size_t count = files.GetCount();
2951 for ( size_t n = 0; n < count; n++ )
2952 {
2953 wxPrintf(_T("\t%s\n"), files[n].c_str());
2954 }
2955 wxPuts(_T("--- End of the file list"));
2956 }
2957 }
2958 else // !list
2959 {
2960 wxChar ch = ftp.SendCommand(buf);
2961 wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
2962 if ( ch )
2963 {
2964 wxPrintf(_T(" (return code %c)"), ch);
2965 }
2966
2967 wxPrintf(_T(", server reply:\n%s\n\n"), ftp.GetLastResult().c_str());
2968 }
2969 }
2970
2971 wxPuts(_T("\n*** done ***"));
2972 }
2973
2974 static void TestFtpUpload()
2975 {
2976 wxPuts(_T("*** Testing wxFTP uploading ***\n"));
2977
2978 // upload a file
2979 static const wxChar *file1 = _T("test1");
2980 static const wxChar *file2 = _T("test2");
2981 wxOutputStream *out = ftp.GetOutputStream(file1);
2982 if ( out )
2983 {
2984 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
2985 out->Write("First hello", 11);
2986 delete out;
2987 }
2988
2989 // send a command to check the remote file
2990 if ( ftp.SendCommand(wxString(_T("STAT ")) + file1) != '2' )
2991 {
2992 wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
2993 }
2994 else
2995 {
2996 wxPrintf(_T("STAT %s returned:\n\n%s\n"),
2997 file1, ftp.GetLastResult().c_str());
2998 }
2999
3000 out = ftp.GetOutputStream(file2);
3001 if ( out )
3002 {
3003 wxPrintf(_T("--- Uploading to %s ---\n"), file1);
3004 out->Write("Second hello", 12);
3005 delete out;
3006 }
3007 }
3008
3009 #endif // TEST_FTP
3010
3011 // ----------------------------------------------------------------------------
3012 // standard paths
3013 // ----------------------------------------------------------------------------
3014
3015 #ifdef TEST_STDPATHS
3016
3017 #include "wx/stdpaths.h"
3018
3019 static void TestStandardPaths()
3020 {
3021 wxPuts(_T("*** Testing wxStandardPaths ***\n"));
3022
3023 wxTheApp->SetAppName(_T("console"));
3024
3025 wxStandardPaths& stdp = wxStandardPaths::Get();
3026 wxPrintf(_T("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
3027 wxPrintf(_T("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
3028 wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
3029 wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
3030 wxPrintf(_T("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
3031 wxPrintf(_T("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
3032 wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
3033 }
3034
3035 #endif // TEST_STDPATHS
3036
3037 // ----------------------------------------------------------------------------
3038 // streams
3039 // ----------------------------------------------------------------------------
3040
3041 #ifdef TEST_STREAMS
3042
3043 #include "wx/wfstream.h"
3044 #include "wx/mstream.h"
3045
3046 static void TestFileStream()
3047 {
3048 wxPuts(_T("*** Testing wxFileInputStream ***"));
3049
3050 static const wxString filename = _T("testdata.fs");
3051 {
3052 wxFileOutputStream fsOut(filename);
3053 fsOut.Write("foo", 3);
3054 }
3055
3056 wxFileInputStream fsIn(filename);
3057 wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
3058 while ( !fsIn.Eof() )
3059 {
3060 wxPutchar(fsIn.GetC());
3061 }
3062
3063 if ( !wxRemoveFile(filename) )
3064 {
3065 wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
3066 }
3067
3068 wxPuts(_T("\n*** wxFileInputStream test done ***"));
3069 }
3070
3071 static void TestMemoryStream()
3072 {
3073 wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
3074
3075 wxMemoryOutputStream memOutStream;
3076 wxPrintf(_T("Initially out stream offset: %lu\n"),
3077 (unsigned long)memOutStream.TellO());
3078
3079 for ( const wxChar *p = _T("Hello, stream!"); *p; p++ )
3080 {
3081 memOutStream.PutC(*p);
3082 }
3083
3084 wxPrintf(_T("Final out stream offset: %lu\n"),
3085 (unsigned long)memOutStream.TellO());
3086
3087 wxPuts(_T("*** Testing wxMemoryInputStream ***"));
3088
3089 wxChar buf[1024];
3090 size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
3091
3092 wxMemoryInputStream memInpStream(buf, len);
3093 wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
3094 while ( !memInpStream.Eof() )
3095 {
3096 wxPutchar(memInpStream.GetC());
3097 }
3098
3099 wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
3100 }
3101
3102 #endif // TEST_STREAMS
3103
3104 // ----------------------------------------------------------------------------
3105 // timers
3106 // ----------------------------------------------------------------------------
3107
3108 #ifdef TEST_TIMER
3109
3110 #include "wx/timer.h"
3111 #include "wx/utils.h"
3112
3113 static void TestStopWatch()
3114 {
3115 wxPuts(_T("*** Testing wxStopWatch ***\n"));
3116
3117 wxStopWatch sw;
3118 sw.Pause();
3119 wxPrintf(_T("Initially paused, after 2 seconds time is..."));
3120 fflush(stdout);
3121 wxSleep(2);
3122 wxPrintf(_T("\t%ldms\n"), sw.Time());
3123
3124 wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
3125 fflush(stdout);
3126 sw.Resume();
3127 wxSleep(3);
3128 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3129
3130 sw.Pause();
3131 wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
3132 fflush(stdout);
3133 wxSleep(2);
3134 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3135
3136 sw.Resume();
3137 wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
3138 fflush(stdout);
3139 wxSleep(2);
3140 wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
3141
3142 wxStopWatch sw2;
3143 wxPuts(_T("\nChecking for 'backwards clock' bug..."));
3144 for ( size_t n = 0; n < 70; n++ )
3145 {
3146 sw2.Start();
3147
3148 for ( size_t m = 0; m < 100000; m++ )
3149 {
3150 if ( sw.Time() < 0 || sw2.Time() < 0 )
3151 {
3152 wxPuts(_T("\ntime is negative - ERROR!"));
3153 }
3154 }
3155
3156 wxPutchar('.');
3157 fflush(stdout);
3158 }
3159
3160 wxPuts(_T(", ok."));
3161 }
3162
3163 #endif // TEST_TIMER
3164
3165 // ----------------------------------------------------------------------------
3166 // vCard support
3167 // ----------------------------------------------------------------------------
3168
3169 #ifdef TEST_VCARD
3170
3171 #include "wx/vcard.h"
3172
3173 static void DumpVObject(size_t level, const wxVCardObject& vcard)
3174 {
3175 void *cookie;
3176 wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
3177 while ( vcObj )
3178 {
3179 wxPrintf(_T("%s%s"),
3180 wxString(_T('\t'), level).c_str(),
3181 vcObj->GetName().c_str());
3182
3183 wxString value;
3184 switch ( vcObj->GetType() )
3185 {
3186 case wxVCardObject::String:
3187 case wxVCardObject::UString:
3188 {
3189 wxString val;
3190 vcObj->GetValue(&val);
3191 value << _T('"') << val << _T('"');
3192 }
3193 break;
3194
3195 case wxVCardObject::Int:
3196 {
3197 unsigned int i;
3198 vcObj->GetValue(&i);
3199 value.Printf(_T("%u"), i);
3200 }
3201 break;
3202
3203 case wxVCardObject::Long:
3204 {
3205 unsigned long l;
3206 vcObj->GetValue(&l);
3207 value.Printf(_T("%lu"), l);
3208 }
3209 break;
3210
3211 case wxVCardObject::None:
3212 break;
3213
3214 case wxVCardObject::Object:
3215 value = _T("<node>");
3216 break;
3217
3218 default:
3219 value = _T("<unknown value type>");
3220 }
3221
3222 if ( !!value )
3223 wxPrintf(_T(" = %s"), value.c_str());
3224 wxPutchar('\n');
3225
3226 DumpVObject(level + 1, *vcObj);
3227
3228 delete vcObj;
3229 vcObj = vcard.GetNextProp(&cookie);
3230 }
3231 }
3232
3233 static void DumpVCardAddresses(const wxVCard& vcard)
3234 {
3235 wxPuts(_T("\nShowing all addresses from vCard:\n"));
3236
3237 size_t nAdr = 0;
3238 void *cookie;
3239 wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
3240 while ( addr )
3241 {
3242 wxString flagsStr;
3243 int flags = addr->GetFlags();
3244 if ( flags & wxVCardAddress::Domestic )
3245 {
3246 flagsStr << _T("domestic ");
3247 }
3248 if ( flags & wxVCardAddress::Intl )
3249 {
3250 flagsStr << _T("international ");
3251 }
3252 if ( flags & wxVCardAddress::Postal )
3253 {
3254 flagsStr << _T("postal ");
3255 }
3256 if ( flags & wxVCardAddress::Parcel )
3257 {
3258 flagsStr << _T("parcel ");
3259 }
3260 if ( flags & wxVCardAddress::Home )
3261 {
3262 flagsStr << _T("home ");
3263 }
3264 if ( flags & wxVCardAddress::Work )
3265 {
3266 flagsStr << _T("work ");
3267 }
3268
3269 wxPrintf(_T("Address %u:\n")
3270 "\tflags = %s\n"
3271 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3272 ++nAdr,
3273 flagsStr.c_str(),
3274 addr->GetPostOffice().c_str(),
3275 addr->GetExtAddress().c_str(),
3276 addr->GetStreet().c_str(),
3277 addr->GetLocality().c_str(),
3278 addr->GetRegion().c_str(),
3279 addr->GetPostalCode().c_str(),
3280 addr->GetCountry().c_str()
3281 );
3282
3283 delete addr;
3284 addr = vcard.GetNextAddress(&cookie);
3285 }
3286 }
3287
3288 static void DumpVCardPhoneNumbers(const wxVCard& vcard)
3289 {
3290 wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
3291
3292 size_t nPhone = 0;
3293 void *cookie;
3294 wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
3295 while ( phone )
3296 {
3297 wxString flagsStr;
3298 int flags = phone->GetFlags();
3299 if ( flags & wxVCardPhoneNumber::Voice )
3300 {
3301 flagsStr << _T("voice ");
3302 }
3303 if ( flags & wxVCardPhoneNumber::Fax )
3304 {
3305 flagsStr << _T("fax ");
3306 }
3307 if ( flags & wxVCardPhoneNumber::Cellular )
3308 {
3309 flagsStr << _T("cellular ");
3310 }
3311 if ( flags & wxVCardPhoneNumber::Modem )
3312 {
3313 flagsStr << _T("modem ");
3314 }
3315 if ( flags & wxVCardPhoneNumber::Home )
3316 {
3317 flagsStr << _T("home ");
3318 }
3319 if ( flags & wxVCardPhoneNumber::Work )
3320 {
3321 flagsStr << _T("work ");
3322 }
3323
3324 wxPrintf(_T("Phone number %u:\n")
3325 "\tflags = %s\n"
3326 "\tvalue = %s\n",
3327 ++nPhone,
3328 flagsStr.c_str(),
3329 phone->GetNumber().c_str()
3330 );
3331
3332 delete phone;
3333 phone = vcard.GetNextPhoneNumber(&cookie);
3334 }
3335 }
3336
3337 static void TestVCardRead()
3338 {
3339 wxPuts(_T("*** Testing wxVCard reading ***\n"));
3340
3341 wxVCard vcard(_T("vcard.vcf"));
3342 if ( !vcard.IsOk() )
3343 {
3344 wxPuts(_T("ERROR: couldn't load vCard."));
3345 }
3346 else
3347 {
3348 // read individual vCard properties
3349 wxVCardObject *vcObj = vcard.GetProperty("FN");
3350 wxString value;
3351 if ( vcObj )
3352 {
3353 vcObj->GetValue(&value);
3354 delete vcObj;
3355 }
3356 else
3357 {
3358 value = _T("<none>");
3359 }
3360
3361 wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
3362
3363
3364 if ( !vcard.GetFullName(&value) )
3365 {
3366 value = _T("<none>");
3367 }
3368
3369 wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
3370
3371 // now show how to deal with multiply occuring properties
3372 DumpVCardAddresses(vcard);
3373 DumpVCardPhoneNumbers(vcard);
3374
3375 // and finally show all
3376 wxPuts(_T("\nNow dumping the entire vCard:\n")
3377 "-----------------------------\n");
3378
3379 DumpVObject(0, vcard);
3380 }
3381 }
3382
3383 static void TestVCardWrite()
3384 {
3385 wxPuts(_T("*** Testing wxVCard writing ***\n"));
3386
3387 wxVCard vcard;
3388 if ( !vcard.IsOk() )
3389 {
3390 wxPuts(_T("ERROR: couldn't create vCard."));
3391 }
3392 else
3393 {
3394 // set some fields
3395 vcard.SetName("Zeitlin", "Vadim");
3396 vcard.SetFullName("Vadim Zeitlin");
3397 vcard.SetOrganization("wxWidgets", "R&D");
3398
3399 // just dump the vCard back
3400 wxPuts(_T("Entire vCard follows:\n"));
3401 wxPuts(vcard.Write());
3402 }
3403 }
3404
3405 #endif // TEST_VCARD
3406
3407 // ----------------------------------------------------------------------------
3408 // wxVolume tests
3409 // ----------------------------------------------------------------------------
3410
3411 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
3412 #undef TEST_VOLUME
3413 #endif
3414
3415 #ifdef TEST_VOLUME
3416
3417 #include "wx/volume.h"
3418
3419 static const wxChar *volumeKinds[] =
3420 {
3421 _T("floppy"),
3422 _T("hard disk"),
3423 _T("CD-ROM"),
3424 _T("DVD-ROM"),
3425 _T("network volume"),
3426 _T("other volume"),
3427 };
3428
3429 static void TestFSVolume()
3430 {
3431 wxPuts(_T("*** Testing wxFSVolume class ***"));
3432
3433 wxArrayString volumes = wxFSVolume::GetVolumes();
3434 size_t count = volumes.GetCount();
3435
3436 if ( !count )
3437 {
3438 wxPuts(_T("ERROR: no mounted volumes?"));
3439 return;
3440 }
3441
3442 wxPrintf(_T("%u mounted volumes found:\n"), count);
3443
3444 for ( size_t n = 0; n < count; n++ )
3445 {
3446 wxFSVolume vol(volumes[n]);
3447 if ( !vol.IsOk() )
3448 {
3449 wxPuts(_T("ERROR: couldn't create volume"));
3450 continue;
3451 }
3452
3453 wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3454 n + 1,
3455 vol.GetDisplayName().c_str(),
3456 vol.GetName().c_str(),
3457 volumeKinds[vol.GetKind()],
3458 vol.IsWritable() ? _T("rw") : _T("ro"),
3459 vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
3460 : _T("fixed"));
3461 }
3462 }
3463
3464 #endif // TEST_VOLUME
3465
3466 // ----------------------------------------------------------------------------
3467 // wide char and Unicode support
3468 // ----------------------------------------------------------------------------
3469
3470 #ifdef TEST_WCHAR
3471
3472 #include "wx/strconv.h"
3473 #include "wx/fontenc.h"
3474 #include "wx/encconv.h"
3475 #include "wx/buffer.h"
3476
3477 static const unsigned char utf8koi8r[] =
3478 {
3479 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3480 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3481 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3482 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3483 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3484 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3485 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3486 };
3487
3488 static const unsigned char utf8iso8859_1[] =
3489 {
3490 0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3491 0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3492 0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3493 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3494 0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3495 };
3496
3497 static const unsigned char utf8Invalid[] =
3498 {
3499 0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3500 0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3501 0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3502 0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3503 0x6c, 0x61, 0x79, 0
3504 };
3505
3506 static const struct Utf8Data
3507 {
3508 const unsigned char *text;
3509 size_t len;
3510 const wxChar *charset;
3511 wxFontEncoding encoding;
3512 } utf8data[] =
3513 {
3514 { utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3515 { utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
3516 { utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
3517 };
3518
3519 static void TestUtf8()
3520 {
3521 wxPuts(_T("*** Testing UTF8 support ***\n"));
3522
3523 char buf[1024];
3524 wchar_t wbuf[1024];
3525
3526 for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
3527 {
3528 const Utf8Data& u8d = utf8data[n];
3529 if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
3530 WXSIZEOF(wbuf)) == (size_t)-1 )
3531 {
3532 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3533 }
3534 else
3535 {
3536 wxCSConv conv(u8d.charset);
3537 if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
3538 {
3539 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
3540 }
3541 else
3542 {
3543 wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
3544 }
3545 }
3546
3547 wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
3548 if ( s.empty() )
3549 s = _T("<< conversion failed >>");
3550 wxPrintf(_T("String in current cset: %s\n"), s.c_str());
3551
3552 }
3553
3554 wxPuts(wxEmptyString);
3555 }
3556
3557 static void TestEncodingConverter()
3558 {
3559 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3560
3561 // using wxEncodingConverter should give the same result as above
3562 char buf[1024];
3563 wchar_t wbuf[1024];
3564 if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
3565 WXSIZEOF(utf8koi8r)) == (size_t)-1 )
3566 {
3567 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3568 }
3569 else
3570 {
3571 wxEncodingConverter ec;
3572 ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
3573 ec.Convert(wbuf, buf);
3574 wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
3575 }
3576
3577 wxPuts(wxEmptyString);
3578 }
3579
3580 #endif // TEST_WCHAR
3581
3582 // ----------------------------------------------------------------------------
3583 // ZIP stream
3584 // ----------------------------------------------------------------------------
3585
3586 #ifdef TEST_ZIP
3587
3588 #include "wx/filesys.h"
3589 #include "wx/fs_zip.h"
3590 #include "wx/zipstrm.h"
3591
3592 static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
3593
3594 static void TestZipStreamRead()
3595 {
3596 wxPuts(_T("*** Testing ZIP reading ***\n"));
3597
3598 static const wxString filename = _T("foo");
3599 wxZipInputStream istr(TESTFILE_ZIP, filename);
3600 wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
3601
3602 wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
3603 while ( !istr.Eof() )
3604 {
3605 wxPutchar(istr.GetC());
3606 fflush(stdout);
3607 }
3608
3609 wxPuts(_T("\n----- done ------"));
3610 }
3611
3612 static void DumpZipDirectory(wxFileSystem& fs,
3613 const wxString& dir,
3614 const wxString& indent)
3615 {
3616 wxString prefix = wxString::Format(_T("%s#zip:%s"),
3617 TESTFILE_ZIP, dir.c_str());
3618 wxString wildcard = prefix + _T("/*");
3619
3620 wxString dirname = fs.FindFirst(wildcard, wxDIR);
3621 while ( !dirname.empty() )
3622 {
3623 if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
3624 {
3625 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3626
3627 break;
3628 }
3629
3630 wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
3631
3632 DumpZipDirectory(fs, dirname,
3633 indent + wxString(_T(' '), 4));
3634
3635 dirname = fs.FindNext();
3636 }
3637
3638 wxString filename = fs.FindFirst(wildcard, wxFILE);
3639 while ( !filename.empty() )
3640 {
3641 if ( !filename.StartsWith(prefix, &filename) )
3642 {
3643 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3644
3645 break;
3646 }
3647
3648 wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
3649
3650 filename = fs.FindNext();
3651 }
3652 }
3653
3654 static void TestZipFileSystem()
3655 {
3656 wxPuts(_T("*** Testing ZIP file system ***\n"));
3657
3658 wxFileSystem::AddHandler(new wxZipFSHandler);
3659 wxFileSystem fs;
3660 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
3661
3662 DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
3663 }
3664
3665 #endif // TEST_ZIP
3666
3667 // ----------------------------------------------------------------------------
3668 // date time
3669 // ----------------------------------------------------------------------------
3670
3671 #ifdef TEST_DATETIME
3672
3673 #include <math.h>
3674
3675 #include "wx/datetime.h"
3676
3677 // this test miscellaneous static wxDateTime functions
3678
3679 #if TEST_ALL
3680
3681 static void TestTimeStatic()
3682 {
3683 wxPuts(_T("\n*** wxDateTime static methods test ***"));
3684
3685 // some info about the current date
3686 int year = wxDateTime::GetCurrentYear();
3687 wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
3688 year,
3689 wxDateTime::IsLeapYear(year) ? "" : "not ",
3690 wxDateTime::GetNumberOfDays(year));
3691
3692 wxDateTime::Month month = wxDateTime::GetCurrentMonth();
3693 wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
3694 wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
3695 wxDateTime::GetMonthName(month).c_str(),
3696 wxDateTime::GetNumberOfDays(month));
3697 }
3698
3699 // test time zones stuff
3700 static void TestTimeZones()
3701 {
3702 wxPuts(_T("\n*** wxDateTime timezone test ***"));
3703
3704 wxDateTime now = wxDateTime::Now();
3705
3706 wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
3707 wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
3708 wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
3709 wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
3710 wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
3711 wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
3712
3713 wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3714
3715 wxDateTime::Tm tm = now.GetTm();
3716 if ( wxDateTime(tm) != now )
3717 {
3718 wxPrintf(_T("ERROR: got %s instead of %s\n"),
3719 wxDateTime(tm).Format().c_str(), now.Format().c_str());
3720 }
3721 }
3722
3723 // test some minimal support for the dates outside the standard range
3724 static void TestTimeRange()
3725 {
3726 wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
3727
3728 static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
3729
3730 wxPrintf(_T("Unix epoch:\t%s\n"),
3731 wxDateTime(2440587.5).Format(fmt).c_str());
3732 wxPrintf(_T("Feb 29, 0: \t%s\n"),
3733 wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
3734 wxPrintf(_T("JDN 0: \t%s\n"),
3735 wxDateTime(0.0).Format(fmt).c_str());
3736 wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3737 wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
3738 wxPrintf(_T("May 29, 2099:\t%s\n"),
3739 wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
3740 }
3741
3742 // test DST calculations
3743 static void TestTimeDST()
3744 {
3745 wxPuts(_T("\n*** wxDateTime DST test ***"));
3746
3747 wxPrintf(_T("DST is%s in effect now.\n\n"),
3748 wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
3749
3750 for ( int year = 1990; year < 2005; year++ )
3751 {
3752 wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3753 year,
3754 wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
3755 wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
3756 }
3757 }
3758
3759 #endif // TEST_ALL
3760
3761 #if TEST_INTERACTIVE
3762
3763 static void TestDateTimeInteractive()
3764 {
3765 wxPuts(_T("\n*** interactive wxDateTime tests ***"));
3766
3767 wxChar buf[128];
3768
3769 for ( ;; )
3770 {
3771 wxPrintf(_T("Enter a date: "));
3772 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
3773 break;
3774
3775 // kill the last '\n'
3776 buf[wxStrlen(buf) - 1] = 0;
3777
3778 wxDateTime dt;
3779 const wxChar *p = dt.ParseDate(buf);
3780 if ( !p )
3781 {
3782 wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
3783
3784 continue;
3785 }
3786 else if ( *p )
3787 {
3788 wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
3789 }
3790
3791 wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3792 dt.Format(_T("%b %d, %Y")).c_str(),
3793 dt.GetDayOfYear(),
3794 dt.GetWeekOfMonth(wxDateTime::Monday_First),
3795 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
3796 dt.GetWeekOfYear(wxDateTime::Monday_First));
3797 }
3798
3799 wxPuts(_T("\n*** done ***"));
3800 }
3801
3802 #endif // TEST_INTERACTIVE
3803
3804 #if TEST_ALL
3805
3806 static void TestTimeMS()
3807 {
3808 wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
3809
3810 wxDateTime dt1 = wxDateTime::Now(),
3811 dt2 = wxDateTime::UNow();
3812
3813 wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
3814 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3815 wxPrintf(_T("Dummy loop: "));
3816 for ( int i = 0; i < 6000; i++ )
3817 {
3818 //for ( int j = 0; j < 10; j++ )
3819 {
3820 wxString s;
3821 s.Printf(_T("%g"), sqrt((float)i));
3822 }
3823
3824 if ( !(i % 100) )
3825 wxPutchar('.');
3826 }
3827 wxPuts(_T(", done"));
3828
3829 dt1 = dt2;
3830 dt2 = wxDateTime::UNow();
3831 wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
3832
3833 wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
3834
3835 wxPuts(_T("\n*** done ***"));
3836 }
3837
3838 static void TestTimeHolidays()
3839 {
3840 wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
3841
3842 wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
3843 wxDateTime dtStart(1, tm.mon, tm.year),
3844 dtEnd = dtStart.GetLastMonthDay();
3845
3846 wxDateTimeArray hol;
3847 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
3848
3849 const wxChar *format = _T("%d-%b-%Y (%a)");
3850
3851 wxPrintf(_T("All holidays between %s and %s:\n"),
3852 dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
3853
3854 size_t count = hol.GetCount();
3855 for ( size_t n = 0; n < count; n++ )
3856 {
3857 wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
3858 }
3859
3860 wxPuts(wxEmptyString);
3861 }
3862
3863 static void TestTimeZoneBug()
3864 {
3865 wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
3866
3867 wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
3868 for ( int i = 0; i < 31; i++ )
3869 {
3870 wxPrintf(_T("Date %s: week day %s.\n"),
3871 date.Format(_T("%d-%m-%Y")).c_str(),
3872 date.GetWeekDayName(date.GetWeekDay()).c_str());
3873
3874 date += wxDateSpan::Day();
3875 }
3876
3877 wxPuts(wxEmptyString);
3878 }
3879
3880 static void TestTimeSpanFormat()
3881 {
3882 wxPuts(_T("\n*** wxTimeSpan tests ***"));
3883
3884 static const wxChar *formats[] =
3885 {
3886 _T("(default) %H:%M:%S"),
3887 _T("%E weeks and %D days"),
3888 _T("%l milliseconds"),
3889 _T("(with ms) %H:%M:%S:%l"),
3890 _T("100%% of minutes is %M"), // test "%%"
3891 _T("%D days and %H hours"),
3892 _T("or also %S seconds"),
3893 };
3894
3895 wxTimeSpan ts1(1, 2, 3, 4),
3896 ts2(111, 222, 333);
3897 for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
3898 {
3899 wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
3900 ts1.Format(formats[n]).c_str(),
3901 ts2.Format(formats[n]).c_str());
3902 }
3903
3904 wxPuts(wxEmptyString);
3905 }
3906
3907 #endif // TEST_ALL
3908
3909 #endif // TEST_DATETIME
3910
3911 // ----------------------------------------------------------------------------
3912 // wxTextInput/OutputStream
3913 // ----------------------------------------------------------------------------
3914
3915 #ifdef TEST_TEXTSTREAM
3916
3917 #include "wx/txtstrm.h"
3918 #include "wx/wfstream.h"
3919
3920 static void TestTextInputStream()
3921 {
3922 wxPuts(_T("\n*** wxTextInputStream test ***"));
3923
3924 wxString filename = _T("testdata.fc");
3925 wxFileInputStream fsIn(filename);
3926 if ( !fsIn.Ok() )
3927 {
3928 wxPuts(_T("ERROR: couldn't open file."));
3929 }
3930 else
3931 {
3932 wxTextInputStream tis(fsIn);
3933
3934 size_t line = 1;
3935 for ( ;; )
3936 {
3937 const wxString s = tis.ReadLine();
3938
3939 // line could be non empty if the last line of the file isn't
3940 // terminated with EOL
3941 if ( fsIn.Eof() && s.empty() )
3942 break;
3943
3944 wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
3945 }
3946 }
3947 }
3948
3949 #endif // TEST_TEXTSTREAM
3950
3951 // ----------------------------------------------------------------------------
3952 // threads
3953 // ----------------------------------------------------------------------------
3954
3955 #ifdef TEST_THREADS
3956
3957 #include "wx/thread.h"
3958
3959 static size_t gs_counter = (size_t)-1;
3960 static wxCriticalSection gs_critsect;
3961 static wxSemaphore gs_cond;
3962
3963 class MyJoinableThread : public wxThread
3964 {
3965 public:
3966 MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
3967 { m_n = n; Create(); }
3968
3969 // thread execution starts here
3970 virtual ExitCode Entry();
3971
3972 private:
3973 size_t m_n;
3974 };
3975
3976 wxThread::ExitCode MyJoinableThread::Entry()
3977 {
3978 unsigned long res = 1;
3979 for ( size_t n = 1; n < m_n; n++ )
3980 {
3981 res *= n;
3982
3983 // it's a loooong calculation :-)
3984 Sleep(100);
3985 }
3986
3987 return (ExitCode)res;
3988 }
3989
3990 class MyDetachedThread : public wxThread
3991 {
3992 public:
3993 MyDetachedThread(size_t n, wxChar ch)
3994 {
3995 m_n = n;
3996 m_ch = ch;
3997 m_cancelled = false;
3998
3999 Create();
4000 }
4001
4002 // thread execution starts here
4003 virtual ExitCode Entry();
4004
4005 // and stops here
4006 virtual void OnExit();
4007
4008 private:
4009 size_t m_n; // number of characters to write
4010 wxChar m_ch; // character to write
4011
4012 bool m_cancelled; // false if we exit normally
4013 };
4014
4015 wxThread::ExitCode MyDetachedThread::Entry()
4016 {
4017 {
4018 wxCriticalSectionLocker lock(gs_critsect);
4019 if ( gs_counter == (size_t)-1 )
4020 gs_counter = 1;
4021 else
4022 gs_counter++;
4023 }
4024
4025 for ( size_t n = 0; n < m_n; n++ )
4026 {
4027 if ( TestDestroy() )
4028 {
4029 m_cancelled = true;
4030
4031 break;
4032 }
4033
4034 wxPutchar(m_ch);
4035 fflush(stdout);
4036
4037 wxThread::Sleep(100);
4038 }
4039
4040 return 0;
4041 }
4042
4043 void MyDetachedThread::OnExit()
4044 {
4045 wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
4046
4047 wxCriticalSectionLocker lock(gs_critsect);
4048 if ( !--gs_counter && !m_cancelled )
4049 gs_cond.Post();
4050 }
4051
4052 static void TestDetachedThreads()
4053 {
4054 wxPuts(_T("\n*** Testing detached threads ***"));
4055
4056 static const size_t nThreads = 3;
4057 MyDetachedThread *threads[nThreads];
4058 size_t n;
4059 for ( n = 0; n < nThreads; n++ )
4060 {
4061 threads[n] = new MyDetachedThread(10, 'A' + n);
4062 }
4063
4064 threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
4065 threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
4066
4067 for ( n = 0; n < nThreads; n++ )
4068 {
4069 threads[n]->Run();
4070 }
4071
4072 // wait until all threads terminate
4073 gs_cond.Wait();
4074
4075 wxPuts(wxEmptyString);
4076 }
4077
4078 static void TestJoinableThreads()
4079 {
4080 wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
4081
4082 // calc 10! in the background
4083 MyJoinableThread thread(10);
4084 thread.Run();
4085
4086 wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
4087 (unsigned long)thread.Wait());
4088 }
4089
4090 static void TestThreadSuspend()
4091 {
4092 wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
4093
4094 MyDetachedThread *thread = new MyDetachedThread(15, 'X');
4095
4096 thread->Run();
4097
4098 // this is for this demo only, in a real life program we'd use another
4099 // condition variable which would be signaled from wxThread::Entry() to
4100 // tell us that the thread really started running - but here just wait a
4101 // bit and hope that it will be enough (the problem is, of course, that
4102 // the thread might still not run when we call Pause() which will result
4103 // in an error)
4104 wxThread::Sleep(300);
4105
4106 for ( size_t n = 0; n < 3; n++ )
4107 {
4108 thread->Pause();
4109
4110 wxPuts(_T("\nThread suspended"));
4111 if ( n > 0 )
4112 {
4113 // don't sleep but resume immediately the first time
4114 wxThread::Sleep(300);
4115 }
4116 wxPuts(_T("Going to resume the thread"));
4117
4118 thread->Resume();
4119 }
4120
4121 wxPuts(_T("Waiting until it terminates now"));
4122
4123 // wait until the thread terminates
4124 gs_cond.Wait();
4125
4126 wxPuts(wxEmptyString);
4127 }
4128
4129 static void TestThreadDelete()
4130 {
4131 // As above, using Sleep() is only for testing here - we must use some
4132 // synchronisation object instead to ensure that the thread is still
4133 // running when we delete it - deleting a detached thread which already
4134 // terminated will lead to a crash!
4135
4136 wxPuts(_T("\n*** Testing thread delete function ***"));
4137
4138 MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
4139
4140 thread0->Delete();
4141
4142 wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
4143
4144 MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
4145
4146 thread1->Run();
4147
4148 wxThread::Sleep(300);
4149
4150 thread1->Delete();
4151
4152 wxPuts(_T("\nDeleted a running thread."));
4153
4154 MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
4155
4156 thread2->Run();
4157
4158 wxThread::Sleep(300);
4159
4160 thread2->Pause();
4161
4162 thread2->Delete();
4163
4164 wxPuts(_T("\nDeleted a sleeping thread."));
4165
4166 MyJoinableThread thread3(20);
4167 thread3.Run();
4168
4169 thread3.Delete();
4170
4171 wxPuts(_T("\nDeleted a joinable thread."));
4172
4173 MyJoinableThread thread4(2);
4174 thread4.Run();
4175
4176 wxThread::Sleep(300);
4177
4178 thread4.Delete();
4179
4180 wxPuts(_T("\nDeleted a joinable thread which already terminated."));
4181
4182 wxPuts(wxEmptyString);
4183 }
4184
4185 class MyWaitingThread : public wxThread
4186 {
4187 public:
4188 MyWaitingThread( wxMutex *mutex, wxCondition *condition )
4189 {
4190 m_mutex = mutex;
4191 m_condition = condition;
4192
4193 Create();
4194 }
4195
4196 virtual ExitCode Entry()
4197 {
4198 wxPrintf(_T("Thread %lu has started running.\n"), GetId());
4199 fflush(stdout);
4200
4201 gs_cond.Post();
4202
4203 wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
4204 fflush(stdout);
4205
4206 m_mutex->Lock();
4207 m_condition->Wait();
4208 m_mutex->Unlock();
4209
4210 wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
4211 fflush(stdout);
4212
4213 return 0;
4214 }
4215
4216 private:
4217 wxMutex *m_mutex;
4218 wxCondition *m_condition;
4219 };
4220
4221 static void TestThreadConditions()
4222 {
4223 wxMutex mutex;
4224 wxCondition condition(mutex);
4225
4226 // otherwise its difficult to understand which log messages pertain to
4227 // which condition
4228 //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
4229 // condition.GetId(), gs_cond.GetId());
4230
4231 // create and launch threads
4232 MyWaitingThread *threads[10];
4233
4234 size_t n;
4235 for ( n = 0; n < WXSIZEOF(threads); n++ )
4236 {
4237 threads[n] = new MyWaitingThread( &mutex, &condition );
4238 }
4239
4240 for ( n = 0; n < WXSIZEOF(threads); n++ )
4241 {
4242 threads[n]->Run();
4243 }
4244
4245 // wait until all threads run
4246 wxPuts(_T("Main thread is waiting for the other threads to start"));
4247 fflush(stdout);
4248
4249 size_t nRunning = 0;
4250 while ( nRunning < WXSIZEOF(threads) )
4251 {
4252 gs_cond.Wait();
4253
4254 nRunning++;
4255
4256 wxPrintf(_T("Main thread: %u already running\n"), nRunning);
4257 fflush(stdout);
4258 }
4259
4260 wxPuts(_T("Main thread: all threads started up."));
4261 fflush(stdout);
4262
4263 wxThread::Sleep(500);
4264
4265 #if 1
4266 // now wake one of them up
4267 wxPrintf(_T("Main thread: about to signal the condition.\n"));
4268 fflush(stdout);
4269 condition.Signal();
4270 #endif
4271
4272 wxThread::Sleep(200);
4273
4274 // wake all the (remaining) threads up, so that they can exit
4275 wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
4276 fflush(stdout);
4277 condition.Broadcast();
4278
4279 // give them time to terminate (dirty!)
4280 wxThread::Sleep(500);
4281 }
4282
4283 #include "wx/utils.h"
4284
4285 class MyExecThread : public wxThread
4286 {
4287 public:
4288 MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
4289 m_command(command)
4290 {
4291 Create();
4292 }
4293
4294 virtual ExitCode Entry()
4295 {
4296 return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
4297 }
4298
4299 private:
4300 wxString m_command;
4301 };
4302
4303 static void TestThreadExec()
4304 {
4305 wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
4306
4307 MyExecThread thread(_T("true"));
4308 thread.Run();
4309
4310 wxPrintf(_T("Main program exit code: %ld.\n"),
4311 wxExecute(_T("false"), wxEXEC_SYNC));
4312
4313 wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
4314 }
4315
4316 // semaphore tests
4317 #include "wx/datetime.h"
4318
4319 class MySemaphoreThread : public wxThread
4320 {
4321 public:
4322 MySemaphoreThread(int i, wxSemaphore *sem)
4323 : wxThread(wxTHREAD_JOINABLE),
4324 m_sem(sem),
4325 m_i(i)
4326 {
4327 Create();
4328 }
4329
4330 virtual ExitCode Entry()
4331 {
4332 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
4333 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4334
4335 m_sem->Wait();
4336
4337 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
4338 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4339
4340 Sleep(1000);
4341
4342 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
4343 wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
4344
4345 m_sem->Post();
4346
4347 return 0;
4348 }
4349
4350 private:
4351 wxSemaphore *m_sem;
4352 int m_i;
4353 };
4354
4355 WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
4356
4357 static void TestSemaphore()
4358 {
4359 wxPuts(_T("*** Testing wxSemaphore class. ***"));
4360
4361 static const int SEM_LIMIT = 3;
4362
4363 wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
4364 ArrayThreads threads;
4365
4366 for ( int i = 0; i < 3*SEM_LIMIT; i++ )
4367 {
4368 threads.Add(new MySemaphoreThread(i, &sem));
4369 threads.Last()->Run();
4370 }
4371
4372 for ( size_t n = 0; n < threads.GetCount(); n++ )
4373 {
4374 threads[n]->Wait();
4375 delete threads[n];
4376 }
4377 }
4378
4379 #endif // TEST_THREADS
4380
4381 // ----------------------------------------------------------------------------
4382 // entry point
4383 // ----------------------------------------------------------------------------
4384
4385 #ifdef TEST_SNGLINST
4386 #include "wx/snglinst.h"
4387 #endif // TEST_SNGLINST
4388
4389 int main(int argc, char **argv)
4390 {
4391 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
4392
4393 wxInitializer initializer;
4394 if ( !initializer )
4395 {
4396 fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
4397
4398 return -1;
4399 }
4400
4401 #ifdef TEST_SNGLINST
4402 wxSingleInstanceChecker checker;
4403 if ( checker.Create(_T(".wxconsole.lock")) )
4404 {
4405 if ( checker.IsAnotherRunning() )
4406 {
4407 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
4408
4409 return 1;
4410 }
4411
4412 // wait some time to give time to launch another instance
4413 wxPrintf(_T("Press \"Enter\" to continue..."));
4414 wxFgetc(stdin);
4415 }
4416 else // failed to create
4417 {
4418 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
4419 }
4420 #endif // TEST_SNGLINST
4421
4422 #ifdef TEST_CMDLINE
4423 TestCmdLineConvert();
4424
4425 #if wxUSE_CMDLINE_PARSER
4426 static const wxCmdLineEntryDesc cmdLineDesc[] =
4427 {
4428 { wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
4429 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
4430 { wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
4431 { wxCMD_LINE_SWITCH, _T("q"), _T("quiet"), _T("be quiet") },
4432
4433 { wxCMD_LINE_OPTION, _T("o"), _T("output"), _T("output file") },
4434 { wxCMD_LINE_OPTION, _T("i"), _T("input"), _T("input dir") },
4435 { wxCMD_LINE_OPTION, _T("s"), _T("size"), _T("output block size"),
4436 wxCMD_LINE_VAL_NUMBER },
4437 { wxCMD_LINE_OPTION, _T("d"), _T("date"), _T("output file date"),
4438 wxCMD_LINE_VAL_DATE },
4439
4440 { wxCMD_LINE_PARAM, NULL, NULL, _T("input file"),
4441 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
4442
4443 { wxCMD_LINE_NONE }
4444 };
4445
4446 #if wxUSE_UNICODE
4447 wxChar **wargv = new wxChar *[argc + 1];
4448
4449 {
4450 int n;
4451
4452 for (n = 0; n < argc; n++ )
4453 {
4454 wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
4455 wargv[n] = wxStrdup(warg);
4456 }
4457
4458 wargv[n] = NULL;
4459 }
4460
4461 #define argv wargv
4462 #endif // wxUSE_UNICODE
4463
4464 wxCmdLineParser parser(cmdLineDesc, argc, argv);
4465
4466 #if wxUSE_UNICODE
4467 {
4468 for ( int n = 0; n < argc; n++ )
4469 free(wargv[n]);
4470
4471 delete [] wargv;
4472 }
4473 #endif // wxUSE_UNICODE
4474
4475 parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
4476 wxCMD_LINE_VAL_STRING,
4477 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
4478
4479 switch ( parser.Parse() )
4480 {
4481 case -1:
4482 wxLogMessage(_T("Help was given, terminating."));
4483 break;
4484
4485 case 0:
4486 ShowCmdLine(parser);
4487 break;
4488
4489 default:
4490 wxLogMessage(_T("Syntax error detected, aborting."));
4491 break;
4492 }
4493 #endif // wxUSE_CMDLINE_PARSER
4494
4495 #endif // TEST_CMDLINE
4496
4497 #ifdef TEST_DIR
4498 #if TEST_ALL
4499 TestDirExists();
4500 TestDirEnum();
4501 #endif
4502 TestDirTraverse();
4503 #endif // TEST_DIR
4504
4505 #ifdef TEST_DLLLOADER
4506 TestDllLoad();
4507 #endif // TEST_DLLLOADER
4508
4509 #ifdef TEST_ENVIRON
4510 TestEnvironment();
4511 #endif // TEST_ENVIRON
4512
4513 #ifdef TEST_EXECUTE
4514 TestExecute();
4515 #endif // TEST_EXECUTE
4516
4517 #ifdef TEST_FILECONF
4518 TestFileConfRead();
4519 #endif // TEST_FILECONF
4520
4521 #ifdef TEST_LIST
4522 TestListCtor();
4523 TestList();
4524 #endif // TEST_LIST
4525
4526 #ifdef TEST_LOCALE
4527 TestDefaultLang();
4528 #endif // TEST_LOCALE
4529
4530 #ifdef TEST_LOG
4531 wxPuts(_T("*** Testing wxLog ***"));
4532
4533 wxString s;
4534 for ( size_t n = 0; n < 8000; n++ )
4535 {
4536 s << (wxChar)(_T('A') + (n % 26));
4537 }
4538
4539 wxLogWarning(_T("The length of the string is %lu"),
4540 (unsigned long)s.length());
4541
4542 wxString msg;
4543 msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
4544
4545 // this one shouldn't be truncated
4546 wxPrintf(msg);
4547
4548 // but this one will because log functions use fixed size buffer
4549 // (note that it doesn't need '\n' at the end neither - will be added
4550 // by wxLog anyhow)
4551 wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
4552 #endif // TEST_LOG
4553
4554 #ifdef TEST_FILE
4555 TestFileRead();
4556 TestTextFileRead();
4557 TestFileCopy();
4558 #endif // TEST_FILE
4559
4560 #ifdef TEST_FILENAME
4561 TestFileNameConstruction();
4562 TestFileNameMakeRelative();
4563 TestFileNameMakeAbsolute();
4564 TestFileNameSplit();
4565 TestFileNameTemp();
4566 TestFileNameCwd();
4567 TestFileNameDirManip();
4568 TestFileNameComparison();
4569 TestFileNameOperations();
4570 #endif // TEST_FILENAME
4571
4572 #ifdef TEST_FILETIME
4573 TestFileGetTimes();
4574 #if 0
4575 TestFileSetTimes();
4576 #endif
4577 #endif // TEST_FILETIME
4578
4579 #ifdef TEST_FTP
4580 wxLog::AddTraceMask(FTP_TRACE_MASK);
4581 if ( TestFtpConnect() )
4582 {
4583 #if TEST_ALL
4584 TestFtpList();
4585 TestFtpDownload();
4586 TestFtpMisc();
4587 TestFtpFileSize();
4588 TestFtpUpload();
4589 #endif // TEST_ALL
4590
4591 #if TEST_INTERACTIVE
4592 TestFtpInteractive();
4593 #endif
4594 }
4595 //else: connecting to the FTP server failed
4596
4597 #if 0
4598 TestFtpWuFtpd();
4599 #endif
4600 #endif // TEST_FTP
4601
4602 #ifdef TEST_HASHMAP
4603 TestHashMap();
4604 #endif // TEST_HASHMAP
4605
4606 #ifdef TEST_HASHSET
4607 TestHashSet();
4608 #endif // TEST_HASHSET
4609
4610 #ifdef TEST_MIME
4611 wxLog::AddTraceMask(_T("mime"));
4612 #if TEST_ALL
4613 TestMimeEnum();
4614 TestMimeOverride();
4615 TestMimeAssociate();
4616 #endif
4617 TestMimeFilename();
4618 #endif // TEST_MIME
4619
4620 #ifdef TEST_INFO_FUNCTIONS
4621 #if TEST_ALL
4622 TestOsInfo();
4623 TestUserInfo();
4624
4625 #if TEST_INTERACTIVE
4626 TestDiskInfo();
4627 #endif
4628 #endif
4629 #endif // TEST_INFO_FUNCTIONS
4630
4631 #ifdef TEST_PATHLIST
4632 TestPathList();
4633 #endif // TEST_PATHLIST
4634
4635 #ifdef TEST_ODBC
4636 TestDbOpen();
4637 #endif // TEST_ODBC
4638
4639 #ifdef TEST_PRINTF
4640 TestPrintf();
4641 #endif // TEST_PRINTF
4642
4643 #ifdef TEST_REGCONF
4644 #if 0
4645 TestRegConfWrite();
4646 #endif
4647 TestRegConfRead();
4648 #endif // TEST_REGCONF
4649
4650 #if defined TEST_REGEX && TEST_INTERACTIVE
4651 TestRegExInteractive();
4652 #endif // defined TEST_REGEX && TEST_INTERACTIVE
4653
4654 #ifdef TEST_REGISTRY
4655 TestRegistryRead();
4656 TestRegistryAssociation();
4657 #endif // TEST_REGISTRY
4658
4659 #ifdef TEST_SOCKETS
4660 TestSocketServer();
4661 TestSocketClient();
4662 #endif // TEST_SOCKETS
4663
4664 #ifdef TEST_STREAMS
4665 #if TEST_ALL
4666 TestFileStream();
4667 #endif
4668 TestMemoryStream();
4669 #endif // TEST_STREAMS
4670
4671 #ifdef TEST_TEXTSTREAM
4672 TestTextInputStream();
4673 #endif // TEST_TEXTSTREAM
4674
4675 #ifdef TEST_THREADS
4676 int nCPUs = wxThread::GetCPUCount();
4677 wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
4678 if ( nCPUs != -1 )
4679 wxThread::SetConcurrency(nCPUs);
4680
4681 TestJoinableThreads();
4682
4683 #if TEST_ALL
4684 TestJoinableThreads();
4685 TestDetachedThreads();
4686 TestThreadSuspend();
4687 TestThreadDelete();
4688 TestThreadConditions();
4689 TestThreadExec();
4690 TestSemaphore();
4691 #endif
4692 #endif // TEST_THREADS
4693
4694 #ifdef TEST_TIMER
4695 TestStopWatch();
4696 #endif // TEST_TIMER
4697
4698 #ifdef TEST_DATETIME
4699 #if TEST_ALL
4700 TestTimeSet();
4701 TestTimeStatic();
4702 TestTimeRange();
4703 TestTimeZones();
4704 TestTimeTicks();
4705 TestTimeJDN();
4706 TestTimeDST();
4707 TestTimeWDays();
4708 TestTimeWNumber();
4709 TestTimeParse();
4710 TestTimeArithmetics();
4711 TestTimeHolidays();
4712 TestTimeSpanFormat();
4713 TestTimeMS();
4714
4715 TestTimeZoneBug();
4716 #endif
4717
4718 #if TEST_INTERACTIVE
4719 TestDateTimeInteractive();
4720 #endif
4721 #endif // TEST_DATETIME
4722
4723 #ifdef TEST_SCOPEGUARD
4724 TestScopeGuard();
4725 #endif
4726
4727 #ifdef TEST_STDPATHS
4728 TestStandardPaths();
4729 #endif
4730
4731 #ifdef TEST_USLEEP
4732 wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
4733 wxUsleep(3000);
4734 #endif // TEST_USLEEP
4735
4736 #ifdef TEST_VCARD
4737 TestVCardRead();
4738 TestVCardWrite();
4739 #endif // TEST_VCARD
4740
4741 #ifdef TEST_VOLUME
4742 TestFSVolume();
4743 #endif // TEST_VOLUME
4744
4745 #ifdef TEST_WCHAR
4746 TestUtf8();
4747 TestEncodingConverter();
4748 #endif // TEST_WCHAR
4749
4750 #ifdef TEST_ZIP
4751 TestZipStreamRead();
4752 TestZipFileSystem();
4753 #endif // TEST_ZIP
4754
4755 wxUnusedVar(argc);
4756 wxUnusedVar(argv);
4757 return 0;
4758 }
4759
wxWidgets (Impactor)