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