projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
remove streams tests: they're very basic and already-existing CppUnit stream tests...
[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 // IMPORTANT NOTE FOR WXWIDGETS USERS:
13 // If you're a wxWidgets user and you're looking at this file to learn how to
14 // structure a wxWidgets console application, then you don't have much to learn.
15 // This application is used more for testing rather than as sample but
16 // basically the following simple block is enough for you to start your
17 // own console application:
18
19 /*
20 int main(int argc, char **argv)
21 {
22 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
23
24 wxInitializer initializer;
25 if ( !initializer )
26 {
27 fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
28 return -1;
29 }
30
31 static const wxCmdLineEntryDesc cmdLineDesc[] =
32 {
33 { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
34 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
35 // ... your other command line options here...
36
37 { wxCMD_LINE_NONE }
38 };
39
40 wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
41 switch ( parser.Parse() )
42 {
43 case -1:
44 wxLogMessage(wxT("Help was given, terminating."));
45 break;
46
47 case 0:
48 // everything is ok; proceed
49 break;
50
51 default:
52 wxLogMessage(wxT("Syntax error detected, aborting."));
53 break;
54 }
55
56 // do something useful here
57
58 return 0;
59 }
60 */
61
62
63 // ============================================================================
64 // declarations
65 // ============================================================================
66
67 // ----------------------------------------------------------------------------
68 // headers
69 // ----------------------------------------------------------------------------
70
71 #include "wx/defs.h"
72
73 #include <stdio.h>
74
75 #include "wx/string.h"
76 #include "wx/file.h"
77 #include "wx/filename.h"
78 #include "wx/app.h"
79 #include "wx/log.h"
80 #include "wx/apptrait.h"
81 #include "wx/platinfo.h"
82 #include "wx/wxchar.h"
83
84 // without this pragma, the stupid compiler precompiles #defines below so that
85 // changing them doesn't "take place" later!
86 #ifdef __VISUALC__
87 #pragma hdrstop
88 #endif
89
90 // ----------------------------------------------------------------------------
91 // conditional compilation
92 // ----------------------------------------------------------------------------
93
94 /*
95 A note about all these conditional compilation macros: this file is used
96 both as a test suite for various non-GUI wxWidgets classes and as a
97 scratchpad for quick tests. So there are two compilation modes: if you
98 define TEST_ALL all tests are run, otherwise you may enable the individual
99 tests individually in the "#else" branch below.
100 */
101
102 // what to test (in alphabetic order)? Define TEST_ALL to 0 to do a single
103 // test, define it to 1 to do all tests.
104 #define TEST_ALL 0
105
106
107 #if TEST_ALL
108 #define TEST_CMDLINE
109 #define TEST_DATETIME
110 #define TEST_DIR
111 #define TEST_DYNLIB
112 #define TEST_ENVIRON
113 #define TEST_FILE
114 #define TEST_FILECONF
115 #define TEST_FILENAME
116 #define TEST_FILETIME
117 #define TEST_FTP
118 #define TEST_INFO_FUNCTIONS
119 #define TEST_LOCALE
120 #define TEST_LOG
121 #define TEST_MIME
122 #define TEST_MODULE
123 #define TEST_PATHLIST
124 #define TEST_PRINTF
125 #define TEST_REGCONF
126 #define TEST_REGEX
127 #define TEST_REGISTRY
128 #define TEST_SCOPEGUARD
129 #define TEST_SNGLINST
130 // #define TEST_SOCKETS --FIXME! (RN)
131 #define TEST_STACKWALKER
132 #define TEST_STDPATHS
133 #else // #if TEST_ALL
134 #define TEST_DATETIME
135 #define TEST_VOLUME
136 #endif
137
138 // some tests are interactive, define this to run them
139 #ifdef TEST_INTERACTIVE
140 #undef TEST_INTERACTIVE
141
142 #define TEST_INTERACTIVE 1
143 #else
144 #define TEST_INTERACTIVE 1
145 #endif
146
147 // ============================================================================
148 // implementation
149 // ============================================================================
150
151 // ----------------------------------------------------------------------------
152 // helper functions
153 // ----------------------------------------------------------------------------
154
155 #if defined(TEST_SOCKETS)
156
157 // replace TABs with \t and CRs with \n
158 static wxString MakePrintable(const wxChar *s)
159 {
160 wxString str(s);
161 (void)str.Replace(wxT("\t"), wxT("\\t"));
162 (void)str.Replace(wxT("\n"), wxT("\\n"));
163 (void)str.Replace(wxT("\r"), wxT("\\r"));
164
165 return str;
166 }
167
168 #endif // MakePrintable() is used
169
170 // ----------------------------------------------------------------------------
171 // wxCmdLineParser
172 // ----------------------------------------------------------------------------
173
174 #ifdef TEST_CMDLINE
175
176 #include "wx/cmdline.h"
177 #include "wx/datetime.h"
178
179 #if wxUSE_CMDLINE_PARSER
180
181 static void ShowCmdLine(const wxCmdLineParser& parser)
182 {
183 wxString s = wxT("Command line parsed successfully:\nInput files: ");
184
185 size_t count = parser.GetParamCount();
186 for ( size_t param = 0; param < count; param++ )
187 {
188 s << parser.GetParam(param) << ' ';
189 }
190
191 s << '\n'
192 << wxT("Verbose:\t") << (parser.Found(wxT("v")) ? wxT("yes") : wxT("no")) << '\n'
193 << wxT("Quiet:\t") << (parser.Found(wxT("q")) ? wxT("yes") : wxT("no")) << '\n';
194
195 wxString strVal;
196 long lVal;
197 double dVal;
198 wxDateTime dt;
199 if ( parser.Found(wxT("o"), &strVal) )
200 s << wxT("Output file:\t") << strVal << '\n';
201 if ( parser.Found(wxT("i"), &strVal) )
202 s << wxT("Input dir:\t") << strVal << '\n';
203 if ( parser.Found(wxT("s"), &lVal) )
204 s << wxT("Size:\t") << lVal << '\n';
205 if ( parser.Found(wxT("f"), &dVal) )
206 s << wxT("Double:\t") << dVal << '\n';
207 if ( parser.Found(wxT("d"), &dt) )
208 s << wxT("Date:\t") << dt.FormatISODate() << '\n';
209 if ( parser.Found(wxT("project_name"), &strVal) )
210 s << wxT("Project:\t") << strVal << '\n';
211
212 wxLogMessage(s);
213 }
214
215 #endif // wxUSE_CMDLINE_PARSER
216
217 static void TestCmdLineConvert()
218 {
219 static const wxChar *cmdlines[] =
220 {
221 wxT("arg1 arg2"),
222 wxT("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
223 wxT("literal \\\" and \"\""),
224 };
225
226 for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
227 {
228 const wxChar *cmdline = cmdlines[n];
229 wxPrintf(wxT("Parsing: %s\n"), cmdline);
230 wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
231
232 size_t count = args.GetCount();
233 wxPrintf(wxT("\targc = %u\n"), count);
234 for ( size_t arg = 0; arg < count; arg++ )
235 {
236 wxPrintf(wxT("\targv[%u] = %s\n"), arg, args[arg].c_str());
237 }
238 }
239 }
240
241 #endif // TEST_CMDLINE
242
243 // ----------------------------------------------------------------------------
244 // wxDir
245 // ----------------------------------------------------------------------------
246
247 #ifdef TEST_DIR
248
249 #include "wx/dir.h"
250
251 #ifdef __UNIX__
252 static const wxChar *ROOTDIR = wxT("/");
253 static const wxChar *TESTDIR = wxT("/usr/local/share");
254 #elif defined(__WXMSW__) || defined(__DOS__) || defined(__OS2__)
255 static const wxChar *ROOTDIR = wxT("c:\\");
256 static const wxChar *TESTDIR = wxT("d:\\");
257 #else
258 #error "don't know where the root directory is"
259 #endif
260
261 static void TestDirEnumHelper(wxDir& dir,
262 int flags = wxDIR_DEFAULT,
263 const wxString& filespec = wxEmptyString)
264 {
265 wxString filename;
266
267 if ( !dir.IsOpened() )
268 return;
269
270 bool cont = dir.GetFirst(&filename, filespec, flags);
271 while ( cont )
272 {
273 wxPrintf(wxT("\t%s\n"), filename.c_str());
274
275 cont = dir.GetNext(&filename);
276 }
277
278 wxPuts(wxEmptyString);
279 }
280
281 #if TEST_ALL
282
283 static void TestDirEnum()
284 {
285 wxPuts(wxT("*** Testing wxDir::GetFirst/GetNext ***"));
286
287 wxString cwd = wxGetCwd();
288 if ( !wxDir::Exists(cwd) )
289 {
290 wxPrintf(wxT("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
291 return;
292 }
293
294 wxDir dir(cwd);
295 if ( !dir.IsOpened() )
296 {
297 wxPrintf(wxT("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
298 return;
299 }
300
301 wxPuts(wxT("Enumerating everything in current directory:"));
302 TestDirEnumHelper(dir);
303
304 wxPuts(wxT("Enumerating really everything in current directory:"));
305 TestDirEnumHelper(dir, wxDIR_DEFAULT | wxDIR_DOTDOT);
306
307 wxPuts(wxT("Enumerating object files in current directory:"));
308 TestDirEnumHelper(dir, wxDIR_DEFAULT, wxT("*.o*"));
309
310 wxPuts(wxT("Enumerating directories in current directory:"));
311 TestDirEnumHelper(dir, wxDIR_DIRS);
312
313 wxPuts(wxT("Enumerating files in current directory:"));
314 TestDirEnumHelper(dir, wxDIR_FILES);
315
316 wxPuts(wxT("Enumerating files including hidden in current directory:"));
317 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
318
319 dir.Open(ROOTDIR);
320
321 wxPuts(wxT("Enumerating everything in root directory:"));
322 TestDirEnumHelper(dir, wxDIR_DEFAULT);
323
324 wxPuts(wxT("Enumerating directories in root directory:"));
325 TestDirEnumHelper(dir, wxDIR_DIRS);
326
327 wxPuts(wxT("Enumerating files in root directory:"));
328 TestDirEnumHelper(dir, wxDIR_FILES);
329
330 wxPuts(wxT("Enumerating files including hidden in root directory:"));
331 TestDirEnumHelper(dir, wxDIR_FILES | wxDIR_HIDDEN);
332
333 wxPuts(wxT("Enumerating files in non existing directory:"));
334 wxDir dirNo(wxT("nosuchdir"));
335 TestDirEnumHelper(dirNo);
336 }
337
338 #endif // TEST_ALL
339
340 class DirPrintTraverser : public wxDirTraverser
341 {
342 public:
343 virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
344 {
345 return wxDIR_CONTINUE;
346 }
347
348 virtual wxDirTraverseResult OnDir(const wxString& dirname)
349 {
350 wxString path, name, ext;
351 wxFileName::SplitPath(dirname, &path, &name, &ext);
352
353 if ( !ext.empty() )
354 name << wxT('.') << ext;
355
356 wxString indent;
357 for ( const wxChar *p = path.c_str(); *p; p++ )
358 {
359 if ( wxIsPathSeparator(*p) )
360 indent += wxT(" ");
361 }
362
363 wxPrintf(wxT("%s%s\n"), indent.c_str(), name.c_str());
364
365 return wxDIR_CONTINUE;
366 }
367 };
368
369 static void TestDirTraverse()
370 {
371 wxPuts(wxT("*** Testing wxDir::Traverse() ***"));
372
373 // enum all files
374 wxArrayString files;
375 size_t n = wxDir::GetAllFiles(TESTDIR, &files);
376 wxPrintf(wxT("There are %u files under '%s'\n"), n, TESTDIR);
377 if ( n > 1 )
378 {
379 wxPrintf(wxT("First one is '%s'\n"), files[0u].c_str());
380 wxPrintf(wxT(" last one is '%s'\n"), files[n - 1].c_str());
381 }
382
383 // enum again with custom traverser
384 wxPuts(wxT("Now enumerating directories:"));
385 wxDir dir(TESTDIR);
386 DirPrintTraverser traverser;
387 dir.Traverse(traverser, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN);
388 }
389
390 #if TEST_ALL
391
392 static void TestDirExists()
393 {
394 wxPuts(wxT("*** Testing wxDir::Exists() ***"));
395
396 static const wxChar *dirnames[] =
397 {
398 wxT("."),
399 #if defined(__WXMSW__)
400 wxT("c:"),
401 wxT("c:\\"),
402 wxT("\\\\share\\file"),
403 wxT("c:\\dos"),
404 wxT("c:\\dos\\"),
405 wxT("c:\\dos\\\\"),
406 wxT("c:\\autoexec.bat"),
407 #elif defined(__UNIX__)
408 wxT("/"),
409 wxT("//"),
410 wxT("/usr/bin"),
411 wxT("/usr//bin"),
412 wxT("/usr///bin"),
413 #endif
414 };
415
416 for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
417 {
418 wxPrintf(wxT("%-40s: %s\n"),
419 dirnames[n],
420 wxDir::Exists(dirnames[n]) ? wxT("exists")
421 : wxT("doesn't exist"));
422 }
423 }
424
425 #endif // TEST_ALL
426
427 #endif // TEST_DIR
428
429 // ----------------------------------------------------------------------------
430 // wxDllLoader
431 // ----------------------------------------------------------------------------
432
433 #ifdef TEST_DYNLIB
434
435 #include "wx/dynlib.h"
436
437 static void TestDllLoad()
438 {
439 #if defined(__WXMSW__)
440 static const wxChar *LIB_NAME = wxT("kernel32.dll");
441 static const wxChar *FUNC_NAME = wxT("lstrlenA");
442 #elif defined(__UNIX__)
443 // weird: using just libc.so does *not* work!
444 static const wxChar *LIB_NAME = wxT("/lib/libc.so.6");
445 static const wxChar *FUNC_NAME = wxT("strlen");
446 #else
447 #error "don't know how to test wxDllLoader on this platform"
448 #endif
449
450 wxPuts(wxT("*** testing basic wxDynamicLibrary functions ***\n"));
451
452 wxDynamicLibrary lib(LIB_NAME);
453 if ( !lib.IsLoaded() )
454 {
455 wxPrintf(wxT("ERROR: failed to load '%s'.\n"), LIB_NAME);
456 }
457 else
458 {
459 typedef int (wxSTDCALL *wxStrlenType)(const char *);
460 wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
461 if ( !pfnStrlen )
462 {
463 wxPrintf(wxT("ERROR: function '%s' wasn't found in '%s'.\n"),
464 FUNC_NAME, LIB_NAME);
465 }
466 else
467 {
468 wxPrintf(wxT("Calling %s dynamically loaded from %s "),
469 FUNC_NAME, LIB_NAME);
470
471 if ( pfnStrlen("foo") != 3 )
472 {
473 wxPrintf(wxT("ERROR: loaded function is not wxStrlen()!\n"));
474 }
475 else
476 {
477 wxPuts(wxT("... ok"));
478 }
479 }
480
481 #ifdef __WXMSW__
482 static const wxChar *FUNC_NAME_AW = wxT("lstrlen");
483
484 typedef int (wxSTDCALL *wxStrlenTypeAorW)(const wxChar *);
485 wxStrlenTypeAorW
486 pfnStrlenAorW = (wxStrlenTypeAorW)lib.GetSymbolAorW(FUNC_NAME_AW);
487 if ( !pfnStrlenAorW )
488 {
489 wxPrintf(wxT("ERROR: function '%s' wasn't found in '%s'.\n"),
490 FUNC_NAME_AW, LIB_NAME);
491 }
492 else
493 {
494 if ( pfnStrlenAorW(wxT("foobar")) != 6 )
495 {
496 wxPrintf(wxT("ERROR: loaded function is not wxStrlen()!\n"));
497 }
498 }
499 #endif // __WXMSW__
500 }
501 }
502
503 #if defined(__WXMSW__) || defined(__UNIX__)
504
505 static void TestDllListLoaded()
506 {
507 wxPuts(wxT("*** testing wxDynamicLibrary::ListLoaded() ***\n"));
508
509 puts("\nLoaded modules:");
510 wxDynamicLibraryDetailsArray dlls = wxDynamicLibrary::ListLoaded();
511 const size_t count = dlls.GetCount();
512 for ( size_t n = 0; n < count; ++n )
513 {
514 const wxDynamicLibraryDetails& details = dlls[n];
515 printf("%-45s", (const char *)details.GetPath().mb_str());
516
517 void *addr wxDUMMY_INITIALIZE(NULL);
518 size_t len wxDUMMY_INITIALIZE(0);
519 if ( details.GetAddress(&addr, &len) )
520 {
521 printf(" %08lx:%08lx",
522 (unsigned long)addr, (unsigned long)((char *)addr + len));
523 }
524
525 printf(" %s\n", (const char *)details.GetVersion().mb_str());
526 }
527 }
528
529 #endif
530
531 #endif // TEST_DYNLIB
532
533 // ----------------------------------------------------------------------------
534 // wxGet/SetEnv
535 // ----------------------------------------------------------------------------
536
537 #ifdef TEST_ENVIRON
538
539 #include "wx/utils.h"
540
541 static wxString MyGetEnv(const wxString& var)
542 {
543 wxString val;
544 if ( !wxGetEnv(var, &val) )
545 val = wxT("<empty>");
546 else
547 val = wxString(wxT('\'')) + val + wxT('\'');
548
549 return val;
550 }
551
552 static void TestEnvironment()
553 {
554 const wxChar *var = wxT("wxTestVar");
555
556 wxPuts(wxT("*** testing environment access functions ***"));
557
558 wxPrintf(wxT("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
559 wxSetEnv(var, wxT("value for wxTestVar"));
560 wxPrintf(wxT("After wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
561 wxSetEnv(var, wxT("another value"));
562 wxPrintf(wxT("After 2nd wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
563 wxUnsetEnv(var);
564 wxPrintf(wxT("After wxUnsetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
565 wxPrintf(wxT("PATH = %s\n"), MyGetEnv(wxT("PATH")).c_str());
566 }
567
568 #endif // TEST_ENVIRON
569
570 // ----------------------------------------------------------------------------
571 // file
572 // ----------------------------------------------------------------------------
573
574 #ifdef TEST_FILE
575
576 #include "wx/file.h"
577 #include "wx/ffile.h"
578 #include "wx/textfile.h"
579
580 static void TestFileRead()
581 {
582 wxPuts(wxT("*** wxFile read test ***"));
583
584 wxFile file(wxT("testdata.fc"));
585 if ( file.IsOpened() )
586 {
587 wxPrintf(wxT("File length: %lu\n"), file.Length());
588
589 wxPuts(wxT("File dump:\n----------"));
590
591 static const size_t len = 1024;
592 wxChar buf[len];
593 for ( ;; )
594 {
595 size_t nRead = file.Read(buf, len);
596 if ( nRead == (size_t)wxInvalidOffset )
597 {
598 wxPrintf(wxT("Failed to read the file."));
599 break;
600 }
601
602 fwrite(buf, nRead, 1, stdout);
603
604 if ( nRead < len )
605 break;
606 }
607
608 wxPuts(wxT("----------"));
609 }
610 else
611 {
612 wxPrintf(wxT("ERROR: can't open test file.\n"));
613 }
614
615 wxPuts(wxEmptyString);
616 }
617
618 static void TestTextFileRead()
619 {
620 wxPuts(wxT("*** wxTextFile read test ***"));
621
622 wxTextFile file(wxT("testdata.fc"));
623 if ( file.Open() )
624 {
625 wxPrintf(wxT("Number of lines: %u\n"), file.GetLineCount());
626 wxPrintf(wxT("Last line: '%s'\n"), file.GetLastLine().c_str());
627
628 wxString s;
629
630 wxPuts(wxT("\nDumping the entire file:"));
631 for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
632 {
633 wxPrintf(wxT("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
634 }
635 wxPrintf(wxT("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
636
637 wxPuts(wxT("\nAnd now backwards:"));
638 for ( s = file.GetLastLine();
639 file.GetCurrentLine() != 0;
640 s = file.GetPrevLine() )
641 {
642 wxPrintf(wxT("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
643 }
644 wxPrintf(wxT("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
645 }
646 else
647 {
648 wxPrintf(wxT("ERROR: can't open '%s'\n"), file.GetName());
649 }
650
651 wxPuts(wxEmptyString);
652 }
653
654 static void TestFileCopy()
655 {
656 wxPuts(wxT("*** Testing wxCopyFile ***"));
657
658 static const wxChar *filename1 = wxT("testdata.fc");
659 static const wxChar *filename2 = wxT("test2");
660 if ( !wxCopyFile(filename1, filename2) )
661 {
662 wxPuts(wxT("ERROR: failed to copy file"));
663 }
664 else
665 {
666 wxFFile f1(filename1, wxT("rb")),
667 f2(filename2, wxT("rb"));
668
669 if ( !f1.IsOpened() || !f2.IsOpened() )
670 {
671 wxPuts(wxT("ERROR: failed to open file(s)"));
672 }
673 else
674 {
675 wxString s1, s2;
676 if ( !f1.ReadAll(&s1) || !f2.ReadAll(&s2) )
677 {
678 wxPuts(wxT("ERROR: failed to read file(s)"));
679 }
680 else
681 {
682 if ( (s1.length() != s2.length()) ||
683 (memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
684 {
685 wxPuts(wxT("ERROR: copy error!"));
686 }
687 else
688 {
689 wxPuts(wxT("File was copied ok."));
690 }
691 }
692 }
693 }
694
695 if ( !wxRemoveFile(filename2) )
696 {
697 wxPuts(wxT("ERROR: failed to remove the file"));
698 }
699
700 wxPuts(wxEmptyString);
701 }
702
703 static void TestTempFile()
704 {
705 wxPuts(wxT("*** wxTempFile test ***"));
706
707 wxTempFile tmpFile;
708 if ( tmpFile.Open(wxT("test2")) && tmpFile.Write(wxT("the answer is 42")) )
709 {
710 if ( tmpFile.Commit() )
711 wxPuts(wxT("File committed."));
712 else
713 wxPuts(wxT("ERROR: could't commit temp file."));
714
715 wxRemoveFile(wxT("test2"));
716 }
717
718 wxPuts(wxEmptyString);
719 }
720
721 #endif // TEST_FILE
722
723 // ----------------------------------------------------------------------------
724 // wxFileConfig
725 // ----------------------------------------------------------------------------
726
727 #ifdef TEST_FILECONF
728
729 #include "wx/confbase.h"
730 #include "wx/fileconf.h"
731
732 static const struct FileConfTestData
733 {
734 const wxChar *name; // value name
735 const wxChar *value; // the value from the file
736 } fcTestData[] =
737 {
738 { wxT("value1"), wxT("one") },
739 { wxT("value2"), wxT("two") },
740 { wxT("novalue"), wxT("default") },
741 };
742
743 static void TestFileConfRead()
744 {
745 wxPuts(wxT("*** testing wxFileConfig loading/reading ***"));
746
747 wxFileConfig fileconf(wxT("test"), wxEmptyString,
748 wxT("testdata.fc"), wxEmptyString,
749 wxCONFIG_USE_RELATIVE_PATH);
750
751 // test simple reading
752 wxPuts(wxT("\nReading config file:"));
753 wxString defValue(wxT("default")), value;
754 for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
755 {
756 const FileConfTestData& data = fcTestData[n];
757 value = fileconf.Read(data.name, defValue);
758 wxPrintf(wxT("\t%s = %s "), data.name, value.c_str());
759 if ( value == data.value )
760 {
761 wxPuts(wxT("(ok)"));
762 }
763 else
764 {
765 wxPrintf(wxT("(ERROR: should be %s)\n"), data.value);
766 }
767 }
768
769 // test enumerating the entries
770 wxPuts(wxT("\nEnumerating all root entries:"));
771 long dummy;
772 wxString name;
773 bool cont = fileconf.GetFirstEntry(name, dummy);
774 while ( cont )
775 {
776 wxPrintf(wxT("\t%s = %s\n"),
777 name.c_str(),
778 fileconf.Read(name.c_str(), wxT("ERROR")).c_str());
779
780 cont = fileconf.GetNextEntry(name, dummy);
781 }
782
783 static const wxChar *testEntry = wxT("TestEntry");
784 wxPrintf(wxT("\nTesting deletion of newly created \"Test\" entry: "));
785 fileconf.Write(testEntry, wxT("A value"));
786 fileconf.DeleteEntry(testEntry);
787 wxPrintf(fileconf.HasEntry(testEntry) ? wxT("ERROR\n") : wxT("ok\n"));
788 }
789
790 #endif // TEST_FILECONF
791
792 // ----------------------------------------------------------------------------
793 // wxFileName
794 // ----------------------------------------------------------------------------
795
796 #ifdef TEST_FILENAME
797
798 #include "wx/filename.h"
799
800 #if 0
801 static void DumpFileName(const wxChar *desc, const wxFileName& fn)
802 {
803 wxPuts(desc);
804
805 wxString full = fn.GetFullPath();
806
807 wxString vol, path, name, ext;
808 wxFileName::SplitPath(full, &vol, &path, &name, &ext);
809
810 wxPrintf(wxT("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
811 full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
812
813 wxFileName::SplitPath(full, &path, &name, &ext);
814 wxPrintf(wxT("or\t\t-> path '%s', name '%s', ext '%s'\n"),
815 path.c_str(), name.c_str(), ext.c_str());
816
817 wxPrintf(wxT("path is also:\t'%s'\n"), fn.GetPath().c_str());
818 wxPrintf(wxT("with volume: \t'%s'\n"),
819 fn.GetPath(wxPATH_GET_VOLUME).c_str());
820 wxPrintf(wxT("with separator:\t'%s'\n"),
821 fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
822 wxPrintf(wxT("with both: \t'%s'\n"),
823 fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
824
825 wxPuts(wxT("The directories in the path are:"));
826 wxArrayString dirs = fn.GetDirs();
827 size_t count = dirs.GetCount();
828 for ( size_t n = 0; n < count; n++ )
829 {
830 wxPrintf(wxT("\t%u: %s\n"), n, dirs[n].c_str());
831 }
832 }
833 #endif
834
835 static void TestFileNameTemp()
836 {
837 wxPuts(wxT("*** testing wxFileName temp file creation ***"));
838
839 static const wxChar *tmpprefixes[] =
840 {
841 wxT(""),
842 wxT("foo"),
843 wxT(".."),
844 wxT("../bar"),
845 #ifdef __UNIX__
846 wxT("/tmp/foo"),
847 wxT("/tmp/foo/bar"), // this one must be an error
848 #endif // __UNIX__
849 };
850
851 for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
852 {
853 wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
854 if ( path.empty() )
855 {
856 // "error" is not in upper case because it may be ok
857 wxPrintf(wxT("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
858 }
859 else
860 {
861 wxPrintf(wxT("Prefix '%s'\t-> temp file '%s'\n"),
862 tmpprefixes[n], path.c_str());
863
864 if ( !wxRemoveFile(path) )
865 {
866 wxLogWarning(wxT("Failed to remove temp file '%s'"),
867 path.c_str());
868 }
869 }
870 }
871 }
872
873 static void TestFileNameDirManip()
874 {
875 // TODO: test AppendDir(), RemoveDir(), ...
876 }
877
878 static void TestFileNameComparison()
879 {
880 // TODO!
881 }
882
883 static void TestFileNameOperations()
884 {
885 // TODO!
886 }
887
888 static void TestFileNameCwd()
889 {
890 // TODO!
891 }
892
893 #endif // TEST_FILENAME
894
895 // ----------------------------------------------------------------------------
896 // wxFileName time functions
897 // ----------------------------------------------------------------------------
898
899 #ifdef TEST_FILETIME
900
901 #include "wx/filename.h"
902 #include "wx/datetime.h"
903
904 static void TestFileGetTimes()
905 {
906 wxFileName fn(wxT("testdata.fc"));
907
908 wxDateTime dtAccess, dtMod, dtCreate;
909 if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
910 {
911 wxPrintf(wxT("ERROR: GetTimes() failed.\n"));
912 }
913 else
914 {
915 static const wxChar *fmt = wxT("%Y-%b-%d %H:%M:%S");
916
917 wxPrintf(wxT("File times for '%s':\n"), fn.GetFullPath().c_str());
918 wxPrintf(wxT("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
919 wxPrintf(wxT("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
920 wxPrintf(wxT("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
921 }
922 }
923
924 #if 0
925 static void TestFileSetTimes()
926 {
927 wxFileName fn(wxT("testdata.fc"));
928
929 if ( !fn.Touch() )
930 {
931 wxPrintf(wxT("ERROR: Touch() failed.\n"));
932 }
933 }
934 #endif
935
936 #endif // TEST_FILETIME
937
938 // ----------------------------------------------------------------------------
939 // wxLocale
940 // ----------------------------------------------------------------------------
941
942 #ifdef TEST_LOCALE
943
944 #include "wx/intl.h"
945 #include "wx/utils.h" // for wxSetEnv
946
947 static wxLocale gs_localeDefault;
948 // NOTE: don't init it here as it needs a wxAppTraits object
949 // and thus must be init-ed after creation of the wxInitializer
950 // class in the main()
951
952 // find the name of the language from its value
953 static const wxChar *GetLangName(int lang)
954 {
955 static const wxChar *languageNames[] =
956 {
957 wxT("DEFAULT"),
958 wxT("UNKNOWN"),
959 wxT("ABKHAZIAN"),
960 wxT("AFAR"),
961 wxT("AFRIKAANS"),
962 wxT("ALBANIAN"),
963 wxT("AMHARIC"),
964 wxT("ARABIC"),
965 wxT("ARABIC_ALGERIA"),
966 wxT("ARABIC_BAHRAIN"),
967 wxT("ARABIC_EGYPT"),
968 wxT("ARABIC_IRAQ"),
969 wxT("ARABIC_JORDAN"),
970 wxT("ARABIC_KUWAIT"),
971 wxT("ARABIC_LEBANON"),
972 wxT("ARABIC_LIBYA"),
973 wxT("ARABIC_MOROCCO"),
974 wxT("ARABIC_OMAN"),
975 wxT("ARABIC_QATAR"),
976 wxT("ARABIC_SAUDI_ARABIA"),
977 wxT("ARABIC_SUDAN"),
978 wxT("ARABIC_SYRIA"),
979 wxT("ARABIC_TUNISIA"),
980 wxT("ARABIC_UAE"),
981 wxT("ARABIC_YEMEN"),
982 wxT("ARMENIAN"),
983 wxT("ASSAMESE"),
984 wxT("AYMARA"),
985 wxT("AZERI"),
986 wxT("AZERI_CYRILLIC"),
987 wxT("AZERI_LATIN"),
988 wxT("BASHKIR"),
989 wxT("BASQUE"),
990 wxT("BELARUSIAN"),
991 wxT("BENGALI"),
992 wxT("BHUTANI"),
993 wxT("BIHARI"),
994 wxT("BISLAMA"),
995 wxT("BRETON"),
996 wxT("BULGARIAN"),
997 wxT("BURMESE"),
998 wxT("CAMBODIAN"),
999 wxT("CATALAN"),
1000 wxT("CHINESE"),
1001 wxT("CHINESE_SIMPLIFIED"),
1002 wxT("CHINESE_TRADITIONAL"),
1003 wxT("CHINESE_HONGKONG"),
1004 wxT("CHINESE_MACAU"),
1005 wxT("CHINESE_SINGAPORE"),
1006 wxT("CHINESE_TAIWAN"),
1007 wxT("CORSICAN"),
1008 wxT("CROATIAN"),
1009 wxT("CZECH"),
1010 wxT("DANISH"),
1011 wxT("DUTCH"),
1012 wxT("DUTCH_BELGIAN"),
1013 wxT("ENGLISH"),
1014 wxT("ENGLISH_UK"),
1015 wxT("ENGLISH_US"),
1016 wxT("ENGLISH_AUSTRALIA"),
1017 wxT("ENGLISH_BELIZE"),
1018 wxT("ENGLISH_BOTSWANA"),
1019 wxT("ENGLISH_CANADA"),
1020 wxT("ENGLISH_CARIBBEAN"),
1021 wxT("ENGLISH_DENMARK"),
1022 wxT("ENGLISH_EIRE"),
1023 wxT("ENGLISH_JAMAICA"),
1024 wxT("ENGLISH_NEW_ZEALAND"),
1025 wxT("ENGLISH_PHILIPPINES"),
1026 wxT("ENGLISH_SOUTH_AFRICA"),
1027 wxT("ENGLISH_TRINIDAD"),
1028 wxT("ENGLISH_ZIMBABWE"),
1029 wxT("ESPERANTO"),
1030 wxT("ESTONIAN"),
1031 wxT("FAEROESE"),
1032 wxT("FARSI"),
1033 wxT("FIJI"),
1034 wxT("FINNISH"),
1035 wxT("FRENCH"),
1036 wxT("FRENCH_BELGIAN"),
1037 wxT("FRENCH_CANADIAN"),
1038 wxT("FRENCH_LUXEMBOURG"),
1039 wxT("FRENCH_MONACO"),
1040 wxT("FRENCH_SWISS"),
1041 wxT("FRISIAN"),
1042 wxT("GALICIAN"),
1043 wxT("GEORGIAN"),
1044 wxT("GERMAN"),
1045 wxT("GERMAN_AUSTRIAN"),
1046 wxT("GERMAN_BELGIUM"),
1047 wxT("GERMAN_LIECHTENSTEIN"),
1048 wxT("GERMAN_LUXEMBOURG"),
1049 wxT("GERMAN_SWISS"),
1050 wxT("GREEK"),
1051 wxT("GREENLANDIC"),
1052 wxT("GUARANI"),
1053 wxT("GUJARATI"),
1054 wxT("HAUSA"),
1055 wxT("HEBREW"),
1056 wxT("HINDI"),
1057 wxT("HUNGARIAN"),
1058 wxT("ICELANDIC"),
1059 wxT("INDONESIAN"),
1060 wxT("INTERLINGUA"),
1061 wxT("INTERLINGUE"),
1062 wxT("INUKTITUT"),
1063 wxT("INUPIAK"),
1064 wxT("IRISH"),
1065 wxT("ITALIAN"),
1066 wxT("ITALIAN_SWISS"),
1067 wxT("JAPANESE"),
1068 wxT("JAVANESE"),
1069 wxT("KANNADA"),
1070 wxT("KASHMIRI"),
1071 wxT("KASHMIRI_INDIA"),
1072 wxT("KAZAKH"),
1073 wxT("KERNEWEK"),
1074 wxT("KINYARWANDA"),
1075 wxT("KIRGHIZ"),
1076 wxT("KIRUNDI"),
1077 wxT("KONKANI"),
1078 wxT("KOREAN"),
1079 wxT("KURDISH"),
1080 wxT("LAOTHIAN"),
1081 wxT("LATIN"),
1082 wxT("LATVIAN"),
1083 wxT("LINGALA"),
1084 wxT("LITHUANIAN"),
1085 wxT("MACEDONIAN"),
1086 wxT("MALAGASY"),
1087 wxT("MALAY"),
1088 wxT("MALAYALAM"),
1089 wxT("MALAY_BRUNEI_DARUSSALAM"),
1090 wxT("MALAY_MALAYSIA"),
1091 wxT("MALTESE"),
1092 wxT("MANIPURI"),
1093 wxT("MAORI"),
1094 wxT("MARATHI"),
1095 wxT("MOLDAVIAN"),
1096 wxT("MONGOLIAN"),
1097 wxT("NAURU"),
1098 wxT("NEPALI"),
1099 wxT("NEPALI_INDIA"),
1100 wxT("NORWEGIAN_BOKMAL"),
1101 wxT("NORWEGIAN_NYNORSK"),
1102 wxT("OCCITAN"),
1103 wxT("ORIYA"),
1104 wxT("OROMO"),
1105 wxT("PASHTO"),
1106 wxT("POLISH"),
1107 wxT("PORTUGUESE"),
1108 wxT("PORTUGUESE_BRAZILIAN"),
1109 wxT("PUNJABI"),
1110 wxT("QUECHUA"),
1111 wxT("RHAETO_ROMANCE"),
1112 wxT("ROMANIAN"),
1113 wxT("RUSSIAN"),
1114 wxT("RUSSIAN_UKRAINE"),
1115 wxT("SAMOAN"),
1116 wxT("SANGHO"),
1117 wxT("SANSKRIT"),
1118 wxT("SCOTS_GAELIC"),
1119 wxT("SERBIAN"),
1120 wxT("SERBIAN_CYRILLIC"),
1121 wxT("SERBIAN_LATIN"),
1122 wxT("SERBO_CROATIAN"),
1123 wxT("SESOTHO"),
1124 wxT("SETSWANA"),
1125 wxT("SHONA"),
1126 wxT("SINDHI"),
1127 wxT("SINHALESE"),
1128 wxT("SISWATI"),
1129 wxT("SLOVAK"),
1130 wxT("SLOVENIAN"),
1131 wxT("SOMALI"),
1132 wxT("SPANISH"),
1133 wxT("SPANISH_ARGENTINA"),
1134 wxT("SPANISH_BOLIVIA"),
1135 wxT("SPANISH_CHILE"),
1136 wxT("SPANISH_COLOMBIA"),
1137 wxT("SPANISH_COSTA_RICA"),
1138 wxT("SPANISH_DOMINICAN_REPUBLIC"),
1139 wxT("SPANISH_ECUADOR"),
1140 wxT("SPANISH_EL_SALVADOR"),
1141 wxT("SPANISH_GUATEMALA"),
1142 wxT("SPANISH_HONDURAS"),
1143 wxT("SPANISH_MEXICAN"),
1144 wxT("SPANISH_MODERN"),
1145 wxT("SPANISH_NICARAGUA"),
1146 wxT("SPANISH_PANAMA"),
1147 wxT("SPANISH_PARAGUAY"),
1148 wxT("SPANISH_PERU"),
1149 wxT("SPANISH_PUERTO_RICO"),
1150 wxT("SPANISH_URUGUAY"),
1151 wxT("SPANISH_US"),
1152 wxT("SPANISH_VENEZUELA"),
1153 wxT("SUNDANESE"),
1154 wxT("SWAHILI"),
1155 wxT("SWEDISH"),
1156 wxT("SWEDISH_FINLAND"),
1157 wxT("TAGALOG"),
1158 wxT("TAJIK"),
1159 wxT("TAMIL"),
1160 wxT("TATAR"),
1161 wxT("TELUGU"),
1162 wxT("THAI"),
1163 wxT("TIBETAN"),
1164 wxT("TIGRINYA"),
1165 wxT("TONGA"),
1166 wxT("TSONGA"),
1167 wxT("TURKISH"),
1168 wxT("TURKMEN"),
1169 wxT("TWI"),
1170 wxT("UIGHUR"),
1171 wxT("UKRAINIAN"),
1172 wxT("URDU"),
1173 wxT("URDU_INDIA"),
1174 wxT("URDU_PAKISTAN"),
1175 wxT("UZBEK"),
1176 wxT("UZBEK_CYRILLIC"),
1177 wxT("UZBEK_LATIN"),
1178 wxT("VIETNAMESE"),
1179 wxT("VOLAPUK"),
1180 wxT("WELSH"),
1181 wxT("WOLOF"),
1182 wxT("XHOSA"),
1183 wxT("YIDDISH"),
1184 wxT("YORUBA"),
1185 wxT("ZHUANG"),
1186 wxT("ZULU"),
1187 };
1188
1189 if ( (size_t)lang < WXSIZEOF(languageNames) )
1190 return languageNames[lang];
1191 else
1192 return wxT("INVALID");
1193 }
1194
1195 static void TestDefaultLang()
1196 {
1197 wxPuts(wxT("*** Testing wxLocale::GetSystemLanguage ***"));
1198
1199 gs_localeDefault.Init(wxLANGUAGE_ENGLISH);
1200
1201 static const wxChar *langStrings[] =
1202 {
1203 NULL, // system default
1204 wxT("C"),
1205 wxT("fr"),
1206 wxT("fr_FR"),
1207 wxT("en"),
1208 wxT("en_GB"),
1209 wxT("en_US"),
1210 wxT("de_DE.iso88591"),
1211 wxT("german"),
1212 wxT("?"), // invalid lang spec
1213 wxT("klingonese"), // I bet on some systems it does exist...
1214 };
1215
1216 wxPrintf(wxT("The default system encoding is %s (%d)\n"),
1217 wxLocale::GetSystemEncodingName().c_str(),
1218 wxLocale::GetSystemEncoding());
1219
1220 for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
1221 {
1222 const wxChar *langStr = langStrings[n];
1223 if ( langStr )
1224 {
1225 // FIXME: this doesn't do anything at all under Windows, we need
1226 // to create a new wxLocale!
1227 wxSetEnv(wxT("LC_ALL"), langStr);
1228 }
1229
1230 int lang = gs_localeDefault.GetSystemLanguage();
1231 wxPrintf(wxT("Locale for '%s' is %s.\n"),
1232 langStr ? langStr : wxT("system default"), GetLangName(lang));
1233 }
1234 }
1235
1236 #endif // TEST_LOCALE
1237
1238 // ----------------------------------------------------------------------------
1239 // MIME types
1240 // ----------------------------------------------------------------------------
1241
1242 #ifdef TEST_MIME
1243
1244 #include "wx/mimetype.h"
1245
1246 static void TestMimeEnum()
1247 {
1248 wxPuts(wxT("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1249
1250 wxArrayString mimetypes;
1251
1252 size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
1253
1254 wxPrintf(wxT("*** All %u known filetypes: ***\n"), count);
1255
1256 wxArrayString exts;
1257 wxString desc;
1258
1259 for ( size_t n = 0; n < count; n++ )
1260 {
1261 wxFileType *filetype =
1262 wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
1263 if ( !filetype )
1264 {
1265 wxPrintf(wxT("nothing known about the filetype '%s'!\n"),
1266 mimetypes[n].c_str());
1267 continue;
1268 }
1269
1270 filetype->GetDescription(&desc);
1271 filetype->GetExtensions(exts);
1272
1273 filetype->GetIcon(NULL);
1274
1275 wxString extsAll;
1276 for ( size_t e = 0; e < exts.GetCount(); e++ )
1277 {
1278 if ( e > 0 )
1279 extsAll << wxT(", ");
1280 extsAll += exts[e];
1281 }
1282
1283 wxPrintf(wxT("\t%s: %s (%s)\n"),
1284 mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
1285 }
1286
1287 wxPuts(wxEmptyString);
1288 }
1289
1290 static void TestMimeFilename()
1291 {
1292 wxPuts(wxT("*** Testing MIME type from filename query ***\n"));
1293
1294 static const wxChar *filenames[] =
1295 {
1296 wxT("readme.txt"),
1297 wxT("document.pdf"),
1298 wxT("image.gif"),
1299 wxT("picture.jpeg"),
1300 };
1301
1302 for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
1303 {
1304 const wxString fname = filenames[n];
1305 wxString ext = fname.AfterLast(wxT('.'));
1306 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
1307 if ( !ft )
1308 {
1309 wxPrintf(wxT("WARNING: extension '%s' is unknown.\n"), ext.c_str());
1310 }
1311 else
1312 {
1313 wxString desc;
1314 if ( !ft->GetDescription(&desc) )
1315 desc = wxT("<no description>");
1316
1317 wxString cmd;
1318 if ( !ft->GetOpenCommand(&cmd,
1319 wxFileType::MessageParameters(fname, wxEmptyString)) )
1320 cmd = wxT("<no command available>");
1321 else
1322 cmd = wxString(wxT('"')) + cmd + wxT('"');
1323
1324 wxPrintf(wxT("To open %s (%s) do %s.\n"),
1325 fname.c_str(), desc.c_str(), cmd.c_str());
1326
1327 delete ft;
1328 }
1329 }
1330
1331 wxPuts(wxEmptyString);
1332 }
1333
1334 // these tests were broken by wxMimeTypesManager changes, temporarily disabling
1335 #if 0
1336
1337 static void TestMimeOverride()
1338 {
1339 wxPuts(wxT("*** Testing wxMimeTypesManager additional files loading ***\n"));
1340
1341 static const wxChar *mailcap = wxT("/tmp/mailcap");
1342 static const wxChar *mimetypes = wxT("/tmp/mime.types");
1343
1344 if ( wxFile::Exists(mailcap) )
1345 wxPrintf(wxT("Loading mailcap from '%s': %s\n"),
1346 mailcap,
1347 wxTheMimeTypesManager->ReadMailcap(mailcap) ? wxT("ok") : wxT("ERROR"));
1348 else
1349 wxPrintf(wxT("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1350 mailcap);
1351
1352 if ( wxFile::Exists(mimetypes) )
1353 wxPrintf(wxT("Loading mime.types from '%s': %s\n"),
1354 mimetypes,
1355 wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? wxT("ok") : wxT("ERROR"));
1356 else
1357 wxPrintf(wxT("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1358 mimetypes);
1359
1360 wxPuts(wxEmptyString);
1361 }
1362
1363 static void TestMimeAssociate()
1364 {
1365 wxPuts(wxT("*** Testing creation of filetype association ***\n"));
1366
1367 wxFileTypeInfo ftInfo(
1368 wxT("application/x-xyz"),
1369 wxT("xyzview '%s'"), // open cmd
1370 wxT(""), // print cmd
1371 wxT("XYZ File"), // description
1372 wxT(".xyz"), // extensions
1373 wxNullPtr // end of extensions
1374 );
1375 ftInfo.SetShortDesc(wxT("XYZFile")); // used under Win32 only
1376
1377 wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
1378 if ( !ft )
1379 {
1380 wxPuts(wxT("ERROR: failed to create association!"));
1381 }
1382 else
1383 {
1384 // TODO: read it back
1385 delete ft;
1386 }
1387
1388 wxPuts(wxEmptyString);
1389 }
1390
1391 #endif // 0
1392
1393 #endif // TEST_MIME
1394
1395 // ----------------------------------------------------------------------------
1396 // module dependencies feature
1397 // ----------------------------------------------------------------------------
1398
1399 #ifdef TEST_MODULE
1400
1401 #include "wx/module.h"
1402
1403 class wxTestModule : public wxModule
1404 {
1405 protected:
1406 virtual bool OnInit() { wxPrintf(wxT("Load module: %s\n"), GetClassInfo()->GetClassName()); return true; }
1407 virtual void OnExit() { wxPrintf(wxT("Unload module: %s\n"), GetClassInfo()->GetClassName()); }
1408 };
1409
1410 class wxTestModuleA : public wxTestModule
1411 {
1412 public:
1413 wxTestModuleA();
1414 private:
1415 DECLARE_DYNAMIC_CLASS(wxTestModuleA)
1416 };
1417
1418 class wxTestModuleB : public wxTestModule
1419 {
1420 public:
1421 wxTestModuleB();
1422 private:
1423 DECLARE_DYNAMIC_CLASS(wxTestModuleB)
1424 };
1425
1426 class wxTestModuleC : public wxTestModule
1427 {
1428 public:
1429 wxTestModuleC();
1430 private:
1431 DECLARE_DYNAMIC_CLASS(wxTestModuleC)
1432 };
1433
1434 class wxTestModuleD : public wxTestModule
1435 {
1436 public:
1437 wxTestModuleD();
1438 private:
1439 DECLARE_DYNAMIC_CLASS(wxTestModuleD)
1440 };
1441
1442 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleC, wxModule)
1443 wxTestModuleC::wxTestModuleC()
1444 {
1445 AddDependency(CLASSINFO(wxTestModuleD));
1446 }
1447
1448 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleA, wxModule)
1449 wxTestModuleA::wxTestModuleA()
1450 {
1451 AddDependency(CLASSINFO(wxTestModuleB));
1452 AddDependency(CLASSINFO(wxTestModuleD));
1453 }
1454
1455 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleD, wxModule)
1456 wxTestModuleD::wxTestModuleD()
1457 {
1458 }
1459
1460 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleB, wxModule)
1461 wxTestModuleB::wxTestModuleB()
1462 {
1463 AddDependency(CLASSINFO(wxTestModuleD));
1464 AddDependency(CLASSINFO(wxTestModuleC));
1465 }
1466
1467 #endif // TEST_MODULE
1468
1469 // ----------------------------------------------------------------------------
1470 // misc information functions
1471 // ----------------------------------------------------------------------------
1472
1473 #ifdef TEST_INFO_FUNCTIONS
1474
1475 #include "wx/utils.h"
1476
1477 #if TEST_INTERACTIVE
1478 static void TestDiskInfo()
1479 {
1480 wxPuts(wxT("*** Testing wxGetDiskSpace() ***"));
1481
1482 for ( ;; )
1483 {
1484 wxChar pathname[128];
1485 wxPrintf(wxT("\nEnter a directory name: "));
1486 if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
1487 break;
1488
1489 // kill the last '\n'
1490 pathname[wxStrlen(pathname) - 1] = 0;
1491
1492 wxLongLong total, free;
1493 if ( !wxGetDiskSpace(pathname, &total, &free) )
1494 {
1495 wxPuts(wxT("ERROR: wxGetDiskSpace failed."));
1496 }
1497 else
1498 {
1499 wxPrintf(wxT("%sKb total, %sKb free on '%s'.\n"),
1500 (total / 1024).ToString().c_str(),
1501 (free / 1024).ToString().c_str(),
1502 pathname);
1503 }
1504 }
1505 }
1506 #endif // TEST_INTERACTIVE
1507
1508 static void TestOsInfo()
1509 {
1510 wxPuts(wxT("*** Testing OS info functions ***\n"));
1511
1512 int major, minor;
1513 wxGetOsVersion(&major, &minor);
1514 wxPrintf(wxT("Running under: %s, version %d.%d\n"),
1515 wxGetOsDescription().c_str(), major, minor);
1516
1517 wxPrintf(wxT("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());
1518
1519 wxPrintf(wxT("Host name is %s (%s).\n"),
1520 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1521
1522 wxPuts(wxEmptyString);
1523 }
1524
1525 static void TestPlatformInfo()
1526 {
1527 wxPuts(wxT("*** Testing wxPlatformInfo functions ***\n"));
1528
1529 // get this platform
1530 wxPlatformInfo plat;
1531
1532 wxPrintf(wxT("Operating system family name is: %s\n"), plat.GetOperatingSystemFamilyName().c_str());
1533 wxPrintf(wxT("Operating system name is: %s\n"), plat.GetOperatingSystemIdName().c_str());
1534 wxPrintf(wxT("Port ID name is: %s\n"), plat.GetPortIdName().c_str());
1535 wxPrintf(wxT("Port ID short name is: %s\n"), plat.GetPortIdShortName().c_str());
1536 wxPrintf(wxT("Architecture is: %s\n"), plat.GetArchName().c_str());
1537 wxPrintf(wxT("Endianness is: %s\n"), plat.GetEndiannessName().c_str());
1538
1539 wxPuts(wxEmptyString);
1540 }
1541
1542 static void TestUserInfo()
1543 {
1544 wxPuts(wxT("*** Testing user info functions ***\n"));
1545
1546 wxPrintf(wxT("User id is:\t%s\n"), wxGetUserId().c_str());
1547 wxPrintf(wxT("User name is:\t%s\n"), wxGetUserName().c_str());
1548 wxPrintf(wxT("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
1549 wxPrintf(wxT("Email address:\t%s\n"), wxGetEmailAddress().c_str());
1550
1551 wxPuts(wxEmptyString);
1552 }
1553
1554 #endif // TEST_INFO_FUNCTIONS
1555
1556 // ----------------------------------------------------------------------------
1557 // path list
1558 // ----------------------------------------------------------------------------
1559
1560 #ifdef TEST_PATHLIST
1561
1562 #ifdef __UNIX__
1563 #define CMD_IN_PATH wxT("ls")
1564 #else
1565 #define CMD_IN_PATH wxT("command.com")
1566 #endif
1567
1568 static void TestPathList()
1569 {
1570 wxPuts(wxT("*** Testing wxPathList ***\n"));
1571
1572 wxPathList pathlist;
1573 pathlist.AddEnvList(wxT("PATH"));
1574 wxString path = pathlist.FindValidPath(CMD_IN_PATH);
1575 if ( path.empty() )
1576 {
1577 wxPrintf(wxT("ERROR: command not found in the path.\n"));
1578 }
1579 else
1580 {
1581 wxPrintf(wxT("Command found in the path as '%s'.\n"), path.c_str());
1582 }
1583 }
1584
1585 #endif // TEST_PATHLIST
1586
1587 // ----------------------------------------------------------------------------
1588 // regular expressions
1589 // ----------------------------------------------------------------------------
1590
1591 #if defined TEST_REGEX && TEST_INTERACTIVE
1592
1593 #include "wx/regex.h"
1594
1595 static void TestRegExInteractive()
1596 {
1597 wxPuts(wxT("*** Testing RE interactively ***"));
1598
1599 for ( ;; )
1600 {
1601 wxChar pattern[128];
1602 wxPrintf(wxT("\nEnter a pattern: "));
1603 if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
1604 break;
1605
1606 // kill the last '\n'
1607 pattern[wxStrlen(pattern) - 1] = 0;
1608
1609 wxRegEx re;
1610 if ( !re.Compile(pattern) )
1611 {
1612 continue;
1613 }
1614
1615 wxChar text[128];
1616 for ( ;; )
1617 {
1618 wxPrintf(wxT("Enter text to match: "));
1619 if ( !wxFgets(text, WXSIZEOF(text), stdin) )
1620 break;
1621
1622 // kill the last '\n'
1623 text[wxStrlen(text) - 1] = 0;
1624
1625 if ( !re.Matches(text) )
1626 {
1627 wxPrintf(wxT("No match.\n"));
1628 }
1629 else
1630 {
1631 wxPrintf(wxT("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
1632
1633 size_t start, len;
1634 for ( size_t n = 1; ; n++ )
1635 {
1636 if ( !re.GetMatch(&start, &len, n) )
1637 {
1638 break;
1639 }
1640
1641 wxPrintf(wxT("Subexpr %u matched '%s'\n"),
1642 n, wxString(text + start, len).c_str());
1643 }
1644 }
1645 }
1646 }
1647 }
1648
1649 #endif // TEST_REGEX
1650
1651 // ----------------------------------------------------------------------------
1652 // printf() tests
1653 // ----------------------------------------------------------------------------
1654
1655 /*
1656 NB: this stuff was taken from the glibc test suite and modified to build
1657 in wxWidgets: if I read the copyright below properly, this shouldn't
1658 be a problem
1659 */
1660
1661 #ifdef TEST_PRINTF
1662
1663 #ifdef wxTEST_PRINTF
1664 // use our functions from wxchar.cpp
1665 #undef wxPrintf
1666 #undef wxSprintf
1667
1668 // NB: do _not_ use WX_ATTRIBUTE_PRINTF here, we have some invalid formats
1669 // in the tests below
1670 int wxPrintf( const wxChar *format, ... );
1671 int wxSprintf( wxChar *str, const wxChar *format, ... );
1672 #endif
1673
1674 #include "wx/longlong.h"
1675
1676 #include <float.h>
1677
1678 static void rfg1 (void);
1679 static void rfg2 (void);
1680
1681
1682 static void
1683 fmtchk (const wxChar *fmt)
1684 {
1685 (void) wxPrintf(wxT("%s:\t`"), fmt);
1686 (void) wxPrintf(fmt, 0x12);
1687 (void) wxPrintf(wxT("'\n"));
1688 }
1689
1690 static void
1691 fmtst1chk (const wxChar *fmt)
1692 {
1693 (void) wxPrintf(wxT("%s:\t`"), fmt);
1694 (void) wxPrintf(fmt, 4, 0x12);
1695 (void) wxPrintf(wxT("'\n"));
1696 }
1697
1698 static void
1699 fmtst2chk (const wxChar *fmt)
1700 {
1701 (void) wxPrintf(wxT("%s:\t`"), fmt);
1702 (void) wxPrintf(fmt, 4, 4, 0x12);
1703 (void) wxPrintf(wxT("'\n"));
1704 }
1705
1706 /* This page is covered by the following copyright: */
1707
1708 /* (C) Copyright C E Chew
1709 *
1710 * Feel free to copy, use and distribute this software provided:
1711 *
1712 * 1. you do not pretend that you wrote it
1713 * 2. you leave this copyright notice intact.
1714 */
1715
1716 /*
1717 * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
1718 */
1719
1720 #define DEC -123
1721 #define INT 255
1722 #define UNS (~0)
1723
1724 /* Formatted Output Test
1725 *
1726 * This exercises the output formatting code.
1727 */
1728
1729 wxChar *PointerNull = NULL;
1730
1731 static void
1732 fp_test (void)
1733 {
1734 int i, j, k, l;
1735 wxChar buf[7];
1736 wxChar *prefix = buf;
1737 wxChar tp[20];
1738
1739 wxPuts(wxT("\nFormatted output test"));
1740 wxPrintf(wxT("prefix 6d 6o 6x 6X 6u\n"));
1741 wxStrcpy(prefix, wxT("%"));
1742 for (i = 0; i < 2; i++) {
1743 for (j = 0; j < 2; j++) {
1744 for (k = 0; k < 2; k++) {
1745 for (l = 0; l < 2; l++) {
1746 wxStrcpy(prefix, wxT("%"));
1747 if (i == 0) wxStrcat(prefix, wxT("-"));
1748 if (j == 0) wxStrcat(prefix, wxT("+"));
1749 if (k == 0) wxStrcat(prefix, wxT("#"));
1750 if (l == 0) wxStrcat(prefix, wxT("0"));
1751 wxPrintf(wxT("%5s |"), prefix);
1752 wxStrcpy(tp, prefix);
1753 wxStrcat(tp, wxT("6d |"));
1754 wxPrintf(tp, DEC);
1755 wxStrcpy(tp, prefix);
1756 wxStrcat(tp, wxT("6o |"));
1757 wxPrintf(tp, INT);
1758 wxStrcpy(tp, prefix);
1759 wxStrcat(tp, wxT("6x |"));
1760 wxPrintf(tp, INT);
1761 wxStrcpy(tp, prefix);
1762 wxStrcat(tp, wxT("6X |"));
1763 wxPrintf(tp, INT);
1764 wxStrcpy(tp, prefix);
1765 wxStrcat(tp, wxT("6u |"));
1766 wxPrintf(tp, UNS);
1767 wxPrintf(wxT("\n"));
1768 }
1769 }
1770 }
1771 }
1772 wxPrintf(wxT("%10s\n"), PointerNull);
1773 wxPrintf(wxT("%-10s\n"), PointerNull);
1774 }
1775
1776 static void TestPrintf()
1777 {
1778 static wxChar shortstr[] = wxT("Hi, Z.");
1779 static wxChar longstr[] = wxT("Good morning, Doctor Chandra. This is Hal. \
1780 I am ready for my first lesson today.");
1781 int result = 0;
1782 wxString test_format;
1783
1784 fmtchk(wxT("%.4x"));
1785 fmtchk(wxT("%04x"));
1786 fmtchk(wxT("%4.4x"));
1787 fmtchk(wxT("%04.4x"));
1788 fmtchk(wxT("%4.3x"));
1789 fmtchk(wxT("%04.3x"));
1790
1791 fmtst1chk(wxT("%.*x"));
1792 fmtst1chk(wxT("%0*x"));
1793 fmtst2chk(wxT("%*.*x"));
1794 fmtst2chk(wxT("%0*.*x"));
1795
1796 wxString bad_format = wxT("bad format:\t\"%b\"\n");
1797 wxPrintf(bad_format.c_str());
1798 wxPrintf(wxT("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
1799
1800 wxPrintf(wxT("decimal negative:\t\"%d\"\n"), -2345);
1801 wxPrintf(wxT("octal negative:\t\"%o\"\n"), -2345);
1802 wxPrintf(wxT("hex negative:\t\"%x\"\n"), -2345);
1803 wxPrintf(wxT("long decimal number:\t\"%ld\"\n"), -123456L);
1804 wxPrintf(wxT("long octal negative:\t\"%lo\"\n"), -2345L);
1805 wxPrintf(wxT("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
1806 wxPrintf(wxT("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
1807 test_format = wxT("left-adjusted ZLDN:\t\"%-010ld\"\n");
1808 wxPrintf(test_format.c_str(), -123456);
1809 wxPrintf(wxT("space-padded LDN:\t\"%10ld\"\n"), -123456L);
1810 wxPrintf(wxT("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
1811
1812 test_format = wxT("zero-padded string:\t\"%010s\"\n");
1813 wxPrintf(test_format.c_str(), shortstr);
1814 test_format = wxT("left-adjusted Z string:\t\"%-010s\"\n");
1815 wxPrintf(test_format.c_str(), shortstr);
1816 wxPrintf(wxT("space-padded string:\t\"%10s\"\n"), shortstr);
1817 wxPrintf(wxT("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
1818 wxPrintf(wxT("null string:\t\"%s\"\n"), PointerNull);
1819 wxPrintf(wxT("limited string:\t\"%.22s\"\n"), longstr);
1820
1821 wxPrintf(wxT("e-style >= 1:\t\"%e\"\n"), 12.34);
1822 wxPrintf(wxT("e-style >= .1:\t\"%e\"\n"), 0.1234);
1823 wxPrintf(wxT("e-style < .1:\t\"%e\"\n"), 0.001234);
1824 wxPrintf(wxT("e-style big:\t\"%.60e\"\n"), 1e20);
1825 wxPrintf(wxT("e-style == .1:\t\"%e\"\n"), 0.1);
1826 wxPrintf(wxT("f-style >= 1:\t\"%f\"\n"), 12.34);
1827 wxPrintf(wxT("f-style >= .1:\t\"%f\"\n"), 0.1234);
1828 wxPrintf(wxT("f-style < .1:\t\"%f\"\n"), 0.001234);
1829 wxPrintf(wxT("g-style >= 1:\t\"%g\"\n"), 12.34);
1830 wxPrintf(wxT("g-style >= .1:\t\"%g\"\n"), 0.1234);
1831 wxPrintf(wxT("g-style < .1:\t\"%g\"\n"), 0.001234);
1832 wxPrintf(wxT("g-style big:\t\"%.60g\"\n"), 1e20);
1833
1834 wxPrintf (wxT(" %6.5f\n"), .099999999860301614);
1835 wxPrintf (wxT(" %6.5f\n"), .1);
1836 wxPrintf (wxT("x%5.4fx\n"), .5);
1837
1838 wxPrintf (wxT("%#03x\n"), 1);
1839
1840 //wxPrintf (wxT("something really insane: %.10000f\n"), 1.0);
1841
1842 {
1843 double d = FLT_MIN;
1844 int niter = 17;
1845
1846 while (niter-- != 0)
1847 wxPrintf (wxT("%.17e\n"), d / 2);
1848 fflush (stdout);
1849 }
1850
1851 #ifndef __WATCOMC__
1852 // Open Watcom cause compiler error here
1853 // Error! E173: col(24) floating-point constant too small to represent
1854 wxPrintf (wxT("%15.5e\n"), 4.9406564584124654e-324);
1855 #endif
1856
1857 #define FORMAT wxT("|%12.4f|%12.4e|%12.4g|\n")
1858 wxPrintf (FORMAT, 0.0, 0.0, 0.0);
1859 wxPrintf (FORMAT, 1.0, 1.0, 1.0);
1860 wxPrintf (FORMAT, -1.0, -1.0, -1.0);
1861 wxPrintf (FORMAT, 100.0, 100.0, 100.0);
1862 wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
1863 wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
1864 wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
1865 wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
1866 wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
1867 #undef FORMAT
1868
1869 {
1870 wxChar buf[20];
1871 int rc = wxSnprintf (buf, WXSIZEOF(buf), wxT("%30s"), wxT("foo"));
1872
1873 wxPrintf(wxT("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
1874 rc, WXSIZEOF(buf), buf);
1875 #if 0
1876 wxChar buf2[512];
1877 wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
1878 wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
1879 #endif
1880 }
1881
1882 fp_test ();
1883
1884 wxPrintf (wxT("%e should be 1.234568e+06\n"), 1234567.8);
1885 wxPrintf (wxT("%f should be 1234567.800000\n"), 1234567.8);
1886 wxPrintf (wxT("%g should be 1.23457e+06\n"), 1234567.8);
1887 wxPrintf (wxT("%g should be 123.456\n"), 123.456);
1888 wxPrintf (wxT("%g should be 1e+06\n"), 1000000.0);
1889 wxPrintf (wxT("%g should be 10\n"), 10.0);
1890 wxPrintf (wxT("%g should be 0.02\n"), 0.02);
1891
1892 {
1893 double x=1.0;
1894 wxPrintf(wxT("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
1895 }
1896
1897 {
1898 wxChar buf[200];
1899
1900 wxSprintf(buf,wxT("%*s%*s%*s"),-1,wxT("one"),-20,wxT("two"),-30,wxT("three"));
1901
1902 result |= wxStrcmp (buf,
1903 wxT("onetwo three "));
1904
1905 wxPuts (result != 0 ? wxT("Test failed!") : wxT("Test ok."));
1906 }
1907
1908 #ifdef wxLongLong_t
1909 {
1910 wxChar buf[200];
1911
1912 wxSprintf(buf, "%07" wxLongLongFmtSpec "o", wxLL(040000000000));
1913 #if 0
1914 // for some reason below line fails under Borland
1915 wxPrintf (wxT("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
1916 #endif
1917
1918 if (wxStrcmp (buf, wxT("40000000000")) != 0)
1919 {
1920 result = 1;
1921 wxPuts (wxT("\tFAILED"));
1922 }
1923 wxUnusedVar(result);
1924 wxPuts (wxEmptyString);
1925 }
1926 #endif // wxLongLong_t
1927
1928 wxPrintf (wxT("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
1929 wxPrintf (wxT("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
1930
1931 wxPuts (wxT("--- Should be no further output. ---"));
1932 rfg1 ();
1933 rfg2 ();
1934
1935 #if 0
1936 {
1937 wxChar bytes[7];
1938 wxChar buf[20];
1939
1940 memset (bytes, '\xff', sizeof bytes);
1941 wxSprintf (buf, wxT("foo%hhn\n"), &bytes[3]);
1942 if (bytes[0] != '\xff' || bytes[1] != '\xff' || bytes[2] != '\xff'
1943 || bytes[4] != '\xff' || bytes[5] != '\xff' || bytes[6] != '\xff')
1944 {
1945 wxPuts (wxT("%hhn overwrite more bytes"));
1946 result = 1;
1947 }
1948 if (bytes[3] != 3)
1949 {
1950 wxPuts (wxT("%hhn wrote incorrect value"));
1951 result = 1;
1952 }
1953 }
1954 #endif
1955 }
1956
1957 static void
1958 rfg1 (void)
1959 {
1960 wxChar buf[100];
1961
1962 wxSprintf (buf, wxT("%5.s"), wxT("xyz"));
1963 if (wxStrcmp (buf, wxT(" ")) != 0)
1964 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" "));
1965 wxSprintf (buf, wxT("%5.f"), 33.3);
1966 if (wxStrcmp (buf, wxT(" 33")) != 0)
1967 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 33"));
1968 wxSprintf (buf, wxT("%8.e"), 33.3e7);
1969 if (wxStrcmp (buf, wxT(" 3e+08")) != 0)
1970 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 3e+08"));
1971 wxSprintf (buf, wxT("%8.E"), 33.3e7);
1972 if (wxStrcmp (buf, wxT(" 3E+08")) != 0)
1973 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 3E+08"));
1974 wxSprintf (buf, wxT("%.g"), 33.3);
1975 if (wxStrcmp (buf, wxT("3e+01")) != 0)
1976 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT("3e+01"));
1977 wxSprintf (buf, wxT("%.G"), 33.3);
1978 if (wxStrcmp (buf, wxT("3E+01")) != 0)
1979 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT("3E+01"));
1980 }
1981
1982 static void
1983 rfg2 (void)
1984 {
1985 int prec;
1986 wxChar buf[100];
1987 wxString test_format;
1988
1989 prec = 0;
1990 wxSprintf (buf, wxT("%.*g"), prec, 3.3);
1991 if (wxStrcmp (buf, wxT("3")) != 0)
1992 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT("3"));
1993 prec = 0;
1994 wxSprintf (buf, wxT("%.*G"), prec, 3.3);
1995 if (wxStrcmp (buf, wxT("3")) != 0)
1996 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT("3"));
1997 prec = 0;
1998 wxSprintf (buf, wxT("%7.*G"), prec, 3.33);
1999 if (wxStrcmp (buf, wxT(" 3")) != 0)
2000 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 3"));
2001 prec = 3;
2002 test_format = wxT("%04.*o");
2003 wxSprintf (buf, test_format.c_str(), prec, 33);
2004 if (wxStrcmp (buf, wxT(" 041")) != 0)
2005 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 041"));
2006 prec = 7;
2007 test_format = wxT("%09.*u");
2008 wxSprintf (buf, test_format.c_str(), prec, 33);
2009 if (wxStrcmp (buf, wxT(" 0000033")) != 0)
2010 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 0000033"));
2011 prec = 3;
2012 test_format = wxT("%04.*x");
2013 wxSprintf (buf, test_format.c_str(), prec, 33);
2014 if (wxStrcmp (buf, wxT(" 021")) != 0)
2015 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 021"));
2016 prec = 3;
2017 test_format = wxT("%04.*X");
2018 wxSprintf (buf, test_format.c_str(), prec, 33);
2019 if (wxStrcmp (buf, wxT(" 021")) != 0)
2020 wxPrintf (wxT("got: '%s', expected: '%s'\n"), buf, wxT(" 021"));
2021 }
2022
2023 #endif // TEST_PRINTF
2024
2025 // ----------------------------------------------------------------------------
2026 // registry and related stuff
2027 // ----------------------------------------------------------------------------
2028
2029 // this is for MSW only
2030 #ifndef __WXMSW__
2031 #undef TEST_REGCONF
2032 #undef TEST_REGISTRY
2033 #endif
2034
2035 #ifdef TEST_REGCONF
2036
2037 #include "wx/confbase.h"
2038 #include "wx/msw/regconf.h"
2039
2040 #if 0
2041 static void TestRegConfWrite()
2042 {
2043 wxConfig *config = new wxConfig(wxT("myapp"));
2044 config->SetPath(wxT("/group1"));
2045 config->Write(wxT("entry1"), wxT("foo"));
2046 config->SetPath(wxT("/group2"));
2047 config->Write(wxT("entry1"), wxT("bar"));
2048 }
2049 #endif
2050
2051 static void TestRegConfRead()
2052 {
2053 wxRegConfig *config = new wxRegConfig(wxT("myapp"));
2054
2055 wxString str;
2056 long dummy;
2057 config->SetPath(wxT("/"));
2058 wxPuts(wxT("Enumerating / subgroups:"));
2059 bool bCont = config->GetFirstGroup(str, dummy);
2060 while(bCont)
2061 {
2062 wxPuts(str);
2063 bCont = config->GetNextGroup(str, dummy);
2064 }
2065 }
2066
2067 #endif // TEST_REGCONF
2068
2069 #ifdef TEST_REGISTRY
2070
2071 #include "wx/msw/registry.h"
2072
2073 // I chose this one because I liked its name, but it probably only exists under
2074 // NT
2075 static const wxChar *TESTKEY =
2076 wxT("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2077
2078 static void TestRegistryRead()
2079 {
2080 wxPuts(wxT("*** testing registry reading ***"));
2081
2082 wxRegKey key(TESTKEY);
2083 wxPrintf(wxT("The test key name is '%s'.\n"), key.GetName().c_str());
2084 if ( !key.Open() )
2085 {
2086 wxPuts(wxT("ERROR: test key can't be opened, aborting test."));
2087
2088 return;
2089 }
2090
2091 size_t nSubKeys, nValues;
2092 if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
2093 {
2094 wxPrintf(wxT("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
2095 }
2096
2097 wxPrintf(wxT("Enumerating values:\n"));
2098
2099 long dummy;
2100 wxString value;
2101 bool cont = key.GetFirstValue(value, dummy);
2102 while ( cont )
2103 {
2104 wxPrintf(wxT("Value '%s': type "), value.c_str());
2105 switch ( key.GetValueType(value) )
2106 {
2107 case wxRegKey::Type_None: wxPrintf(wxT("ERROR (none)")); break;
2108 case wxRegKey::Type_String: wxPrintf(wxT("SZ")); break;
2109 case wxRegKey::Type_Expand_String: wxPrintf(wxT("EXPAND_SZ")); break;
2110 case wxRegKey::Type_Binary: wxPrintf(wxT("BINARY")); break;
2111 case wxRegKey::Type_Dword: wxPrintf(wxT("DWORD")); break;
2112 case wxRegKey::Type_Multi_String: wxPrintf(wxT("MULTI_SZ")); break;
2113 default: wxPrintf(wxT("other (unknown)")); break;
2114 }
2115
2116 wxPrintf(wxT(", value = "));
2117 if ( key.IsNumericValue(value) )
2118 {
2119 long val;
2120 key.QueryValue(value, &val);
2121 wxPrintf(wxT("%ld"), val);
2122 }
2123 else // string
2124 {
2125 wxString val;
2126 key.QueryValue(value, val);
2127 wxPrintf(wxT("'%s'"), val.c_str());
2128
2129 key.QueryRawValue(value, val);
2130 wxPrintf(wxT(" (raw value '%s')"), val.c_str());
2131 }
2132
2133 wxPutchar('\n');
2134
2135 cont = key.GetNextValue(value, dummy);
2136 }
2137 }
2138
2139 static void TestRegistryAssociation()
2140 {
2141 /*
2142 The second call to deleteself genertaes an error message, with a
2143 messagebox saying .flo is crucial to system operation, while the .ddf
2144 call also fails, but with no error message
2145 */
2146
2147 wxRegKey key;
2148
2149 key.SetName(wxT("HKEY_CLASSES_ROOT\\.ddf") );
2150 key.Create();
2151 key = wxT("ddxf_auto_file") ;
2152 key.SetName(wxT("HKEY_CLASSES_ROOT\\.flo") );
2153 key.Create();
2154 key = wxT("ddxf_auto_file") ;
2155 key.SetName(wxT("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2156 key.Create();
2157 key = wxT("program,0") ;
2158 key.SetName(wxT("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2159 key.Create();
2160 key = wxT("program \"%1\"") ;
2161
2162 key.SetName(wxT("HKEY_CLASSES_ROOT\\.ddf") );
2163 key.DeleteSelf();
2164 key.SetName(wxT("HKEY_CLASSES_ROOT\\.flo") );
2165 key.DeleteSelf();
2166 key.SetName(wxT("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2167 key.DeleteSelf();
2168 key.SetName(wxT("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2169 key.DeleteSelf();
2170 }
2171
2172 #endif // TEST_REGISTRY
2173
2174 // ----------------------------------------------------------------------------
2175 // scope guard
2176 // ----------------------------------------------------------------------------
2177
2178 #ifdef TEST_SCOPEGUARD
2179
2180 #include "wx/scopeguard.h"
2181
2182 static void function0() { puts("function0()"); }
2183 static void function1(int n) { printf("function1(%d)\n", n); }
2184 static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
2185
2186 struct Object
2187 {
2188 void method0() { printf("method0()\n"); }
2189 void method1(int n) { printf("method1(%d)\n", n); }
2190 void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
2191 };
2192
2193 static void TestScopeGuard()
2194 {
2195 wxON_BLOCK_EXIT0(function0);
2196 wxON_BLOCK_EXIT1(function1, 17);
2197 wxON_BLOCK_EXIT2(function2, 3.14, 'p');
2198
2199 Object obj;
2200 wxON_BLOCK_EXIT_OBJ0(obj, Object::method0);
2201 wxON_BLOCK_EXIT_OBJ1(obj, Object::method1, 7);
2202 wxON_BLOCK_EXIT_OBJ2(obj, Object::method2, 2.71, 'e');
2203
2204 wxScopeGuard dismissed = wxMakeGuard(function0);
2205 dismissed.Dismiss();
2206 }
2207
2208 #endif
2209
2210 // ----------------------------------------------------------------------------
2211 // sockets
2212 // ----------------------------------------------------------------------------
2213
2214 #ifdef TEST_SOCKETS
2215
2216 #include "wx/socket.h"
2217 #include "wx/protocol/protocol.h"
2218 #include "wx/protocol/http.h"
2219
2220 static void TestSocketServer()
2221 {
2222 wxPuts(wxT("*** Testing wxSocketServer ***\n"));
2223
2224 static const int PORT = 3000;
2225
2226 wxIPV4address addr;
2227 addr.Service(PORT);
2228
2229 wxSocketServer *server = new wxSocketServer(addr);
2230 if ( !server->Ok() )
2231 {
2232 wxPuts(wxT("ERROR: failed to bind"));
2233
2234 return;
2235 }
2236
2237 bool quit = false;
2238 while ( !quit )
2239 {
2240 wxPrintf(wxT("Server: waiting for connection on port %d...\n"), PORT);
2241
2242 wxSocketBase *socket = server->Accept();
2243 if ( !socket )
2244 {
2245 wxPuts(wxT("ERROR: wxSocketServer::Accept() failed."));
2246 break;
2247 }
2248
2249 wxPuts(wxT("Server: got a client."));
2250
2251 server->SetTimeout(60); // 1 min
2252
2253 bool close = false;
2254 while ( !close && socket->IsConnected() )
2255 {
2256 wxString s;
2257 wxChar ch = wxT('\0');
2258 for ( ;; )
2259 {
2260 if ( socket->Read(&ch, sizeof(ch)).Error() )
2261 {
2262 // don't log error if the client just close the connection
2263 if ( socket->IsConnected() )
2264 {
2265 wxPuts(wxT("ERROR: in wxSocket::Read."));
2266 }
2267
2268 break;
2269 }
2270
2271 if ( ch == '\r' )
2272 continue;
2273
2274 if ( ch == '\n' )
2275 break;
2276
2277 s += ch;
2278 }
2279
2280 if ( ch != '\n' )
2281 {
2282 break;
2283 }
2284
2285 wxPrintf(wxT("Server: got '%s'.\n"), s.c_str());
2286 if ( s == wxT("close") )
2287 {
2288 wxPuts(wxT("Closing connection"));
2289
2290 close = true;
2291 }
2292 else if ( s == wxT("quit") )
2293 {
2294 close =
2295 quit = true;
2296
2297 wxPuts(wxT("Shutting down the server"));
2298 }
2299 else // not a special command
2300 {
2301 socket->Write(s.MakeUpper().c_str(), s.length());
2302 socket->Write("\r\n", 2);
2303 wxPrintf(wxT("Server: wrote '%s'.\n"), s.c_str());
2304 }
2305 }
2306
2307 if ( !close )
2308 {
2309 wxPuts(wxT("Server: lost a client unexpectedly."));
2310 }
2311
2312 socket->Destroy();
2313 }
2314
2315 // same as "delete server" but is consistent with GUI programs
2316 server->Destroy();
2317 }
2318
2319 static void TestSocketClient()
2320 {
2321 wxPuts(wxT("*** Testing wxSocketClient ***\n"));
2322
2323 static const wxChar *hostname = wxT("www.wxwidgets.org");
2324
2325 wxIPV4address addr;
2326 addr.Hostname(hostname);
2327 addr.Service(80);
2328
2329 wxPrintf(wxT("--- Attempting to connect to %s:80...\n"), hostname);
2330
2331 wxSocketClient client;
2332 if ( !client.Connect(addr) )
2333 {
2334 wxPrintf(wxT("ERROR: failed to connect to %s\n"), hostname);
2335 }
2336 else
2337 {
2338 wxPrintf(wxT("--- Connected to %s:%u...\n"),
2339 addr.Hostname().c_str(), addr.Service());
2340
2341 wxChar buf[8192];
2342
2343 // could use simply "GET" here I suppose
2344 wxString cmdGet =
2345 wxString::Format(wxT("GET http://%s/\r\n"), hostname);
2346 client.Write(cmdGet, cmdGet.length());
2347 wxPrintf(wxT("--- Sent command '%s' to the server\n"),
2348 MakePrintable(cmdGet).c_str());
2349 client.Read(buf, WXSIZEOF(buf));
2350 wxPrintf(wxT("--- Server replied:\n%s"), buf);
2351 }
2352 }
2353
2354 #endif // TEST_SOCKETS
2355
2356 // ----------------------------------------------------------------------------
2357 // FTP
2358 // ----------------------------------------------------------------------------
2359
2360 #ifdef TEST_FTP
2361
2362 #include "wx/protocol/ftp.h"
2363 #include "wx/protocol/log.h"
2364
2365 #define FTP_ANONYMOUS
2366
2367 static wxFTP *ftp;
2368
2369 #ifdef FTP_ANONYMOUS
2370 static const wxChar *directory = wxT("/pub");
2371 static const wxChar *filename = wxT("welcome.msg");
2372 #else
2373 static const wxChar *directory = wxT("/etc");
2374 static const wxChar *filename = wxT("issue");
2375 #endif
2376
2377 static bool TestFtpConnect()
2378 {
2379 wxPuts(wxT("*** Testing FTP connect ***"));
2380
2381 #ifdef FTP_ANONYMOUS
2382 static const wxChar *hostname = wxT("ftp.wxwidgets.org");
2383
2384 wxPrintf(wxT("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
2385 #else // !FTP_ANONYMOUS
2386 static const wxChar *hostname = "localhost";
2387
2388 wxChar user[256];
2389 wxFgets(user, WXSIZEOF(user), stdin);
2390 user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
2391 ftp->SetUser(user);
2392
2393 wxChar password[256];
2394 wxPrintf(wxT("Password for %s: "), password);
2395 wxFgets(password, WXSIZEOF(password), stdin);
2396 password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
2397 ftp->SetPassword(password);
2398
2399 wxPrintf(wxT("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
2400 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2401
2402 if ( !ftp->Connect(hostname) )
2403 {
2404 wxPrintf(wxT("ERROR: failed to connect to %s\n"), hostname);
2405
2406 return false;
2407 }
2408 else
2409 {
2410 wxPrintf(wxT("--- Connected to %s, current directory is '%s'\n"),
2411 hostname, ftp->Pwd().c_str());
2412 ftp->Close();
2413 }
2414
2415 return true;
2416 }
2417
2418 static void TestFtpList()
2419 {
2420 wxPuts(wxT("*** Testing wxFTP file listing ***\n"));
2421
2422 // test CWD
2423 if ( !ftp->ChDir(directory) )
2424 {
2425 wxPrintf(wxT("ERROR: failed to cd to %s\n"), directory);
2426 }
2427
2428 wxPrintf(wxT("Current directory is '%s'\n"), ftp->Pwd().c_str());
2429
2430 // test NLIST and LIST
2431 wxArrayString files;
2432 if ( !ftp->GetFilesList(files) )
2433 {
2434 wxPuts(wxT("ERROR: failed to get NLIST of files"));
2435 }
2436 else
2437 {
2438 wxPrintf(wxT("Brief list of files under '%s':\n"), ftp->Pwd().c_str());
2439 size_t count = files.GetCount();
2440 for ( size_t n = 0; n < count; n++ )
2441 {
2442 wxPrintf(wxT("\t%s\n"), files[n].c_str());
2443 }
2444 wxPuts(wxT("End of the file list"));
2445 }
2446
2447 if ( !ftp->GetDirList(files) )
2448 {
2449 wxPuts(wxT("ERROR: failed to get LIST of files"));
2450 }
2451 else
2452 {
2453 wxPrintf(wxT("Detailed list of files under '%s':\n"), ftp->Pwd().c_str());
2454 size_t count = files.GetCount();
2455 for ( size_t n = 0; n < count; n++ )
2456 {
2457 wxPrintf(wxT("\t%s\n"), files[n].c_str());
2458 }
2459 wxPuts(wxT("End of the file list"));
2460 }
2461
2462 if ( !ftp->ChDir(wxT("..")) )
2463 {
2464 wxPuts(wxT("ERROR: failed to cd to .."));
2465 }
2466
2467 wxPrintf(wxT("Current directory is '%s'\n"), ftp->Pwd().c_str());
2468 }
2469
2470 static void TestFtpDownload()
2471 {
2472 wxPuts(wxT("*** Testing wxFTP download ***\n"));
2473
2474 // test RETR
2475 wxInputStream *in = ftp->GetInputStream(filename);
2476 if ( !in )
2477 {
2478 wxPrintf(wxT("ERROR: couldn't get input stream for %s\n"), filename);
2479 }
2480 else
2481 {
2482 size_t size = in->GetSize();
2483 wxPrintf(wxT("Reading file %s (%u bytes)..."), filename, size);
2484 fflush(stdout);
2485
2486 wxChar *data = new wxChar[size];
2487 if ( !in->Read(data, size) )
2488 {
2489 wxPuts(wxT("ERROR: read error"));
2490 }
2491 else
2492 {
2493 wxPrintf(wxT("\nContents of %s:\n%s\n"), filename, data);
2494 }
2495
2496 delete [] data;
2497 delete in;
2498 }
2499 }
2500
2501 static void TestFtpFileSize()
2502 {
2503 wxPuts(wxT("*** Testing FTP SIZE command ***"));
2504
2505 if ( !ftp->ChDir(directory) )
2506 {
2507 wxPrintf(wxT("ERROR: failed to cd to %s\n"), directory);
2508 }
2509
2510 wxPrintf(wxT("Current directory is '%s'\n"), ftp->Pwd().c_str());
2511
2512 if ( ftp->FileExists(filename) )
2513 {
2514 int size = ftp->GetFileSize(filename);
2515 if ( size == -1 )
2516 wxPrintf(wxT("ERROR: couldn't get size of '%s'\n"), filename);
2517 else
2518 wxPrintf(wxT("Size of '%s' is %d bytes.\n"), filename, size);
2519 }
2520 else
2521 {
2522 wxPrintf(wxT("ERROR: '%s' doesn't exist\n"), filename);
2523 }
2524 }
2525
2526 static void TestFtpMisc()
2527 {
2528 wxPuts(wxT("*** Testing miscellaneous wxFTP functions ***"));
2529
2530 if ( ftp->SendCommand(wxT("STAT")) != '2' )
2531 {
2532 wxPuts(wxT("ERROR: STAT failed"));
2533 }
2534 else
2535 {
2536 wxPrintf(wxT("STAT returned:\n\n%s\n"), ftp->GetLastResult().c_str());
2537 }
2538
2539 if ( ftp->SendCommand(wxT("HELP SITE")) != '2' )
2540 {
2541 wxPuts(wxT("ERROR: HELP SITE failed"));
2542 }
2543 else
2544 {
2545 wxPrintf(wxT("The list of site-specific commands:\n\n%s\n"),
2546 ftp->GetLastResult().c_str());
2547 }
2548 }
2549
2550 #if TEST_INTERACTIVE
2551
2552 static void TestFtpInteractive()
2553 {
2554 wxPuts(wxT("\n*** Interactive wxFTP test ***"));
2555
2556 wxChar buf[128];
2557
2558 for ( ;; )
2559 {
2560 wxPrintf(wxT("Enter FTP command: "));
2561 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
2562 break;
2563
2564 // kill the last '\n'
2565 buf[wxStrlen(buf) - 1] = 0;
2566
2567 // special handling of LIST and NLST as they require data connection
2568 wxString start(buf, 4);
2569 start.MakeUpper();
2570 if ( start == wxT("LIST") || start == wxT("NLST") )
2571 {
2572 wxString wildcard;
2573 if ( wxStrlen(buf) > 4 )
2574 wildcard = buf + 5;
2575
2576 wxArrayString files;
2577 if ( !ftp->GetList(files, wildcard, start == wxT("LIST")) )
2578 {
2579 wxPrintf(wxT("ERROR: failed to get %s of files\n"), start.c_str());
2580 }
2581 else
2582 {
2583 wxPrintf(wxT("--- %s of '%s' under '%s':\n"),
2584 start.c_str(), wildcard.c_str(), ftp->Pwd().c_str());
2585 size_t count = files.GetCount();
2586 for ( size_t n = 0; n < count; n++ )
2587 {
2588 wxPrintf(wxT("\t%s\n"), files[n].c_str());
2589 }
2590 wxPuts(wxT("--- End of the file list"));
2591 }
2592 }
2593 else // !list
2594 {
2595 wxChar ch = ftp->SendCommand(buf);
2596 wxPrintf(wxT("Command %s"), ch ? wxT("succeeded") : wxT("failed"));
2597 if ( ch )
2598 {
2599 wxPrintf(wxT(" (return code %c)"), ch);
2600 }
2601
2602 wxPrintf(wxT(", server reply:\n%s\n\n"), ftp->GetLastResult().c_str());
2603 }
2604 }
2605
2606 wxPuts(wxT("\n*** done ***"));
2607 }
2608
2609 #endif // TEST_INTERACTIVE
2610
2611 static void TestFtpUpload()
2612 {
2613 wxPuts(wxT("*** Testing wxFTP uploading ***\n"));
2614
2615 // upload a file
2616 static const wxChar *file1 = wxT("test1");
2617 static const wxChar *file2 = wxT("test2");
2618 wxOutputStream *out = ftp->GetOutputStream(file1);
2619 if ( out )
2620 {
2621 wxPrintf(wxT("--- Uploading to %s ---\n"), file1);
2622 out->Write("First hello", 11);
2623 delete out;
2624 }
2625
2626 // send a command to check the remote file
2627 if ( ftp->SendCommand(wxString(wxT("STAT ")) + file1) != '2' )
2628 {
2629 wxPrintf(wxT("ERROR: STAT %s failed\n"), file1);
2630 }
2631 else
2632 {
2633 wxPrintf(wxT("STAT %s returned:\n\n%s\n"),
2634 file1, ftp->GetLastResult().c_str());
2635 }
2636
2637 out = ftp->GetOutputStream(file2);
2638 if ( out )
2639 {
2640 wxPrintf(wxT("--- Uploading to %s ---\n"), file1);
2641 out->Write("Second hello", 12);
2642 delete out;
2643 }
2644 }
2645
2646 #endif // TEST_FTP
2647
2648 // ----------------------------------------------------------------------------
2649 // stack backtrace
2650 // ----------------------------------------------------------------------------
2651
2652 #ifdef TEST_STACKWALKER
2653
2654 #if wxUSE_STACKWALKER
2655
2656 #include "wx/stackwalk.h"
2657
2658 class StackDump : public wxStackWalker
2659 {
2660 public:
2661 StackDump(const char *argv0)
2662 : wxStackWalker(argv0)
2663 {
2664 }
2665
2666 virtual void Walk(size_t skip = 1, size_t maxdepth = wxSTACKWALKER_MAX_DEPTH)
2667 {
2668 wxPuts(wxT("Stack dump:"));
2669
2670 wxStackWalker::Walk(skip, maxdepth);
2671 }
2672
2673 protected:
2674 virtual void OnStackFrame(const wxStackFrame& frame)
2675 {
2676 printf("[%2d] ", (int) frame.GetLevel());
2677
2678 wxString name = frame.GetName();
2679 if ( !name.empty() )
2680 {
2681 printf("%-20.40s", (const char*)name.mb_str());
2682 }
2683 else
2684 {
2685 printf("0x%08lx", (unsigned long)frame.GetAddress());
2686 }
2687
2688 if ( frame.HasSourceLocation() )
2689 {
2690 printf("\t%s:%d",
2691 (const char*)frame.GetFileName().mb_str(),
2692 (int)frame.GetLine());
2693 }
2694
2695 puts("");
2696
2697 wxString type, val;
2698 for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
2699 {
2700 printf("\t%s %s = %s\n", (const char*)type.mb_str(),
2701 (const char*)name.mb_str(),
2702 (const char*)val.mb_str());
2703 }
2704 }
2705 };
2706
2707 static void TestStackWalk(const char *argv0)
2708 {
2709 wxPuts(wxT("*** Testing wxStackWalker ***\n"));
2710
2711 StackDump dump(argv0);
2712 dump.Walk();
2713 }
2714
2715 #endif // wxUSE_STACKWALKER
2716
2717 #endif // TEST_STACKWALKER
2718
2719 // ----------------------------------------------------------------------------
2720 // standard paths
2721 // ----------------------------------------------------------------------------
2722
2723 #ifdef TEST_STDPATHS
2724
2725 #include "wx/stdpaths.h"
2726 #include "wx/wxchar.h" // wxPrintf
2727
2728 static void TestStandardPaths()
2729 {
2730 wxPuts(wxT("*** Testing wxStandardPaths ***\n"));
2731
2732 wxTheApp->SetAppName(wxT("console"));
2733
2734 wxStandardPathsBase& stdp = wxStandardPaths::Get();
2735 wxPrintf(wxT("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
2736 wxPrintf(wxT("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
2737 wxPrintf(wxT("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
2738 wxPrintf(wxT("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
2739 wxPrintf(wxT("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
2740 wxPrintf(wxT("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
2741 wxPrintf(wxT("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
2742 wxPrintf(wxT("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
2743 wxPrintf(wxT("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
2744 wxPrintf(wxT("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
2745 wxPrintf(wxT("Localized res. dir:\t%s\n"),
2746 stdp.GetLocalizedResourcesDir(wxT("fr")).c_str());
2747 wxPrintf(wxT("Message catalogs dir:\t%s\n"),
2748 stdp.GetLocalizedResourcesDir
2749 (
2750 wxT("fr"),
2751 wxStandardPaths::ResourceCat_Messages
2752 ).c_str());
2753 }
2754
2755 #endif // TEST_STDPATHS
2756
2757 // ----------------------------------------------------------------------------
2758 // wxVolume tests
2759 // ----------------------------------------------------------------------------
2760
2761 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
2762 #undef TEST_VOLUME
2763 #endif
2764
2765 #ifdef TEST_VOLUME
2766
2767 #include "wx/volume.h"
2768
2769 static const wxChar *volumeKinds[] =
2770 {
2771 wxT("floppy"),
2772 wxT("hard disk"),
2773 wxT("CD-ROM"),
2774 wxT("DVD-ROM"),
2775 wxT("network volume"),
2776 wxT("other volume"),
2777 };
2778
2779 static void TestFSVolume()
2780 {
2781 wxPuts(wxT("*** Testing wxFSVolume class ***"));
2782
2783 wxArrayString volumes = wxFSVolume::GetVolumes();
2784 size_t count = volumes.GetCount();
2785
2786 if ( !count )
2787 {
2788 wxPuts(wxT("ERROR: no mounted volumes?"));
2789 return;
2790 }
2791
2792 wxPrintf(wxT("%u mounted volumes found:\n"), count);
2793
2794 for ( size_t n = 0; n < count; n++ )
2795 {
2796 wxFSVolume vol(volumes[n]);
2797 if ( !vol.IsOk() )
2798 {
2799 wxPuts(wxT("ERROR: couldn't create volume"));
2800 continue;
2801 }
2802
2803 wxPrintf(wxT("%u: %s (%s), %s, %s, %s\n"),
2804 n + 1,
2805 vol.GetDisplayName().c_str(),
2806 vol.GetName().c_str(),
2807 volumeKinds[vol.GetKind()],
2808 vol.IsWritable() ? wxT("rw") : wxT("ro"),
2809 vol.GetFlags() & wxFS_VOL_REMOVABLE ? wxT("removable")
2810 : wxT("fixed"));
2811 }
2812 }
2813
2814 #endif // TEST_VOLUME
2815
2816 // ----------------------------------------------------------------------------
2817 // date time
2818 // ----------------------------------------------------------------------------
2819
2820 #ifdef TEST_DATETIME
2821
2822 #include "wx/math.h"
2823 #include "wx/datetime.h"
2824
2825 #if TEST_INTERACTIVE
2826
2827 static void TestDateTimeInteractive()
2828 {
2829 wxPuts(wxT("\n*** interactive wxDateTime tests ***"));
2830
2831 wxChar buf[128];
2832
2833 for ( ;; )
2834 {
2835 wxPrintf(wxT("Enter a date: "));
2836 if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
2837 break;
2838
2839 // kill the last '\n'
2840 buf[wxStrlen(buf) - 1] = 0;
2841
2842 wxDateTime dt;
2843 const wxChar *p = dt.ParseDate(buf);
2844 if ( !p )
2845 {
2846 wxPrintf(wxT("ERROR: failed to parse the date '%s'.\n"), buf);
2847
2848 continue;
2849 }
2850 else if ( *p )
2851 {
2852 wxPrintf(wxT("WARNING: parsed only first %u characters.\n"), p - buf);
2853 }
2854
2855 wxPrintf(wxT("%s: day %u, week of month %u/%u, week of year %u\n"),
2856 dt.Format(wxT("%b %d, %Y")).c_str(),
2857 dt.GetDayOfYear(),
2858 dt.GetWeekOfMonth(wxDateTime::Monday_First),
2859 dt.GetWeekOfMonth(wxDateTime::Sunday_First),
2860 dt.GetWeekOfYear(wxDateTime::Monday_First));
2861 }
2862
2863 wxPuts(wxT("\n*** done ***"));
2864 }
2865
2866 #endif // TEST_INTERACTIVE
2867 #endif // TEST_DATETIME
2868
2869 // ----------------------------------------------------------------------------
2870 // entry point
2871 // ----------------------------------------------------------------------------
2872
2873 #ifdef TEST_SNGLINST
2874 #include "wx/snglinst.h"
2875 #endif // TEST_SNGLINST
2876
2877 int main(int argc, char **argv)
2878 {
2879 #if wxUSE_UNICODE
2880 wxChar **wxArgv = new wxChar *[argc + 1];
2881
2882 {
2883 int n;
2884
2885 for (n = 0; n < argc; n++ )
2886 {
2887 wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
2888 wxArgv[n] = wxStrdup(warg);
2889 }
2890
2891 wxArgv[n] = NULL;
2892 }
2893 #else // !wxUSE_UNICODE
2894 #define wxArgv argv
2895 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
2896
2897 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
2898
2899 wxInitializer initializer;
2900 if ( !initializer )
2901 {
2902 fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
2903
2904 return -1;
2905 }
2906
2907 #ifdef TEST_SNGLINST
2908 wxSingleInstanceChecker checker;
2909 if ( checker.Create(wxT(".wxconsole.lock")) )
2910 {
2911 if ( checker.IsAnotherRunning() )
2912 {
2913 wxPrintf(wxT("Another instance of the program is running, exiting.\n"));
2914
2915 return 1;
2916 }
2917
2918 // wait some time to give time to launch another instance
2919 wxPrintf(wxT("Press \"Enter\" to continue..."));
2920 wxFgetc(stdin);
2921 }
2922 else // failed to create
2923 {
2924 wxPrintf(wxT("Failed to init wxSingleInstanceChecker.\n"));
2925 }
2926 #endif // TEST_SNGLINST
2927
2928 #ifdef TEST_CMDLINE
2929 TestCmdLineConvert();
2930
2931 #if wxUSE_CMDLINE_PARSER
2932 static const wxCmdLineEntryDesc cmdLineDesc[] =
2933 {
2934 { wxCMD_LINE_SWITCH, "h", "help", "show this help message",
2935 wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
2936 { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
2937 { wxCMD_LINE_SWITCH, "q", "quiet", "be quiet" },
2938
2939 { wxCMD_LINE_OPTION, "o", "output", "output file" },
2940 { wxCMD_LINE_OPTION, "i", "input", "input dir" },
2941 { wxCMD_LINE_OPTION, "s", "size", "output block size",
2942 wxCMD_LINE_VAL_NUMBER },
2943 { wxCMD_LINE_OPTION, "d", "date", "output file date",
2944 wxCMD_LINE_VAL_DATE },
2945 { wxCMD_LINE_OPTION, "f", "double", "output double",
2946 wxCMD_LINE_VAL_DOUBLE },
2947
2948 { wxCMD_LINE_PARAM, NULL, NULL, "input file",
2949 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
2950
2951 { wxCMD_LINE_NONE }
2952 };
2953
2954 wxCmdLineParser parser(cmdLineDesc, argc, wxArgv);
2955
2956 parser.AddOption(wxT("project_name"), wxT(""), wxT("full path to project file"),
2957 wxCMD_LINE_VAL_STRING,
2958 wxCMD_LINE_OPTION_MANDATORY | wxCMD_LINE_NEEDS_SEPARATOR);
2959
2960 switch ( parser.Parse() )
2961 {
2962 case -1:
2963 wxLogMessage(wxT("Help was given, terminating."));
2964 break;
2965
2966 case 0:
2967 ShowCmdLine(parser);
2968 break;
2969
2970 default:
2971 wxLogMessage(wxT("Syntax error detected, aborting."));
2972 break;
2973 }
2974 #endif // wxUSE_CMDLINE_PARSER
2975
2976 #endif // TEST_CMDLINE
2977
2978 #ifdef TEST_DIR
2979 #if TEST_ALL
2980 TestDirExists();
2981 TestDirEnum();
2982 #endif
2983 TestDirTraverse();
2984 #endif // TEST_DIR
2985
2986 #ifdef TEST_DYNLIB
2987 TestDllLoad();
2988 TestDllListLoaded();
2989 #endif // TEST_DYNLIB
2990
2991 #ifdef TEST_ENVIRON
2992 TestEnvironment();
2993 #endif // TEST_ENVIRON
2994
2995 #ifdef TEST_FILECONF
2996 TestFileConfRead();
2997 #endif // TEST_FILECONF
2998
2999 #ifdef TEST_LOCALE
3000 TestDefaultLang();
3001 #endif // TEST_LOCALE
3002
3003 #ifdef TEST_LOG
3004 wxPuts(wxT("*** Testing wxLog ***"));
3005
3006 wxString s;
3007 for ( size_t n = 0; n < 8000; n++ )
3008 {
3009 s << (wxChar)(wxT('A') + (n % 26));
3010 }
3011
3012 wxLogWarning(wxT("The length of the string is %lu"),
3013 (unsigned long)s.length());
3014
3015 wxString msg;
3016 msg.Printf(wxT("A very very long message: '%s', the end!\n"), s.c_str());
3017
3018 // this one shouldn't be truncated
3019 wxPrintf(msg);
3020
3021 // but this one will because log functions use fixed size buffer
3022 // (note that it doesn't need '\n' at the end neither - will be added
3023 // by wxLog anyhow)
3024 wxLogMessage(wxT("A very very long message 2: '%s', the end!"), s.c_str());
3025 #endif // TEST_LOG
3026
3027 #ifdef TEST_FILE
3028 TestFileRead();
3029 TestTextFileRead();
3030 TestFileCopy();
3031 TestTempFile();
3032 #endif // TEST_FILE
3033
3034 #ifdef TEST_FILENAME
3035 TestFileNameTemp();
3036 TestFileNameCwd();
3037 TestFileNameDirManip();
3038 TestFileNameComparison();
3039 TestFileNameOperations();
3040 #endif // TEST_FILENAME
3041
3042 #ifdef TEST_FILETIME
3043 TestFileGetTimes();
3044 #if 0
3045 TestFileSetTimes();
3046 #endif
3047 #endif // TEST_FILETIME
3048
3049 #ifdef TEST_FTP
3050 wxLog::AddTraceMask(FTP_TRACE_MASK);
3051
3052 // wxFTP cannot be a static variable as its ctor needs to access
3053 // wxWidgets internals after it has been initialized
3054 ftp = new wxFTP;
3055 ftp->SetLog(new wxProtocolLog(FTP_TRACE_MASK));
3056
3057 if ( TestFtpConnect() )
3058 {
3059 #if TEST_ALL
3060 TestFtpList();
3061 TestFtpDownload();
3062 TestFtpMisc();
3063 TestFtpFileSize();
3064 TestFtpUpload();
3065 #endif // TEST_ALL
3066
3067 #if TEST_INTERACTIVE
3068 //TestFtpInteractive();
3069 #endif
3070 }
3071 //else: connecting to the FTP server failed
3072
3073 delete ftp;
3074 #endif // TEST_FTP
3075
3076 #ifdef TEST_MIME
3077 //wxLog::AddTraceMask(wxT("mime"));
3078 TestMimeEnum();
3079 #if 0
3080 TestMimeOverride();
3081 TestMimeAssociate();
3082 #endif
3083 TestMimeFilename();
3084 #endif // TEST_MIME
3085
3086 #ifdef TEST_INFO_FUNCTIONS
3087 TestOsInfo();
3088 TestPlatformInfo();
3089 TestUserInfo();
3090
3091 #if TEST_INTERACTIVE
3092 TestDiskInfo();
3093 #endif
3094 #endif // TEST_INFO_FUNCTIONS
3095
3096 #ifdef TEST_PATHLIST
3097 TestPathList();
3098 #endif // TEST_PATHLIST
3099
3100 #ifdef TEST_PRINTF
3101 TestPrintf();
3102 #endif // TEST_PRINTF
3103
3104 #ifdef TEST_REGCONF
3105 #if 0
3106 TestRegConfWrite();
3107 #endif
3108 TestRegConfRead();
3109 #endif // TEST_REGCONF
3110
3111 #if defined TEST_REGEX && TEST_INTERACTIVE
3112 TestRegExInteractive();
3113 #endif // defined TEST_REGEX && TEST_INTERACTIVE
3114
3115 #ifdef TEST_REGISTRY
3116 TestRegistryRead();
3117 TestRegistryAssociation();
3118 #endif // TEST_REGISTRY
3119
3120 #ifdef TEST_SOCKETS
3121 TestSocketServer();
3122 TestSocketClient();
3123 #endif // TEST_SOCKETS
3124
3125 #ifdef TEST_DATETIME
3126 #if TEST_INTERACTIVE
3127 TestDateTimeInteractive();
3128 #endif
3129 #endif // TEST_DATETIME
3130
3131 #ifdef TEST_SCOPEGUARD
3132 TestScopeGuard();
3133 #endif
3134
3135 #ifdef TEST_STACKWALKER
3136 #if wxUSE_STACKWALKER
3137 TestStackWalk(argv[0]);
3138 #endif
3139 #endif // TEST_STACKWALKER
3140
3141 #ifdef TEST_STDPATHS
3142 TestStandardPaths();
3143 #endif
3144
3145 #ifdef TEST_USLEEP
3146 wxPuts(wxT("Sleeping for 3 seconds... z-z-z-z-z..."));
3147 wxUsleep(3000);
3148 #endif // TEST_USLEEP
3149
3150 #ifdef TEST_VOLUME
3151 TestFSVolume();
3152 #endif // TEST_VOLUME
3153
3154 #if wxUSE_UNICODE
3155 {
3156 for ( int n = 0; n < argc; n++ )
3157 free(wxArgv[n]);
3158
3159 delete [] wxArgv;
3160 }
3161 #endif // wxUSE_UNICODE
3162
3163 wxUnusedVar(argc);
3164 wxUnusedVar(argv);
3165 return 0;
3166 }
wxWidgets (Impactor)