1 /////////////////////////////////////////////////////////////////////////////
2 // Name: samples/console/console.cpp
3 // Purpose: A sample console (as opposed to GUI) program using wxWidgets
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
24 #include "wx/string.h"
28 #include "wx/apptrait.h"
29 #include "wx/platinfo.h"
30 #include "wx/wxchar.h"
32 // without this pragma, the stupid compiler precompiles #defines below so that
33 // changing them doesn't "take place" later!
38 // ----------------------------------------------------------------------------
39 // conditional compilation
40 // ----------------------------------------------------------------------------
43 A note about all these conditional compilation macros: this file is used
44 both as a test suite for various non-GUI wxWidgets classes and as a
45 scratchpad for quick tests. So there are two compilation modes: if you
46 define TEST_ALL all tests are run, otherwise you may enable the individual
47 tests individually in the "#else" branch below.
50 // what to test (in alphabetic order)? Define TEST_ALL to 0 to do a single
51 // test, define it to 1 to do all tests.
66 // #define TEST_FTP --FIXME! (RN)
67 #define TEST_INFO_FUNCTIONS
77 #define TEST_SCOPEGUARD
79 // #define TEST_SOCKETS --FIXME! (RN)
80 #define TEST_STACKWALKER
83 #define TEST_TEXTSTREAM
86 // #define TEST_VCARD -- don't enable this (VZ)
87 // #define TEST_VOLUME --FIXME! (RN)
94 // some tests are interactive, define this to run them
95 #ifdef TEST_INTERACTIVE
96 #undef TEST_INTERACTIVE
98 #define TEST_INTERACTIVE 1
100 #define TEST_INTERACTIVE 0
103 // ============================================================================
105 // ============================================================================
107 // ----------------------------------------------------------------------------
109 // ----------------------------------------------------------------------------
111 #if defined(TEST_SOCKETS)
113 // replace TABs with \t and CRs with \n
114 static wxString
MakePrintable(const wxChar
*s
)
117 (void)str
.Replace(_T("\t"), _T("\\t"));
118 (void)str
.Replace(_T("\n"), _T("\\n"));
119 (void)str
.Replace(_T("\r"), _T("\\r"));
124 #endif // MakePrintable() is used
126 // ----------------------------------------------------------------------------
128 // ----------------------------------------------------------------------------
132 #include "wx/cmdline.h"
133 #include "wx/datetime.h"
135 #if wxUSE_CMDLINE_PARSER
137 static void ShowCmdLine(const wxCmdLineParser
& parser
)
139 wxString s
= _T("Command line parsed successfully:\nInput files: ");
141 size_t count
= parser
.GetParamCount();
142 for ( size_t param
= 0; param
< count
; param
++ )
144 s
<< parser
.GetParam(param
) << ' ';
148 << _T("Verbose:\t") << (parser
.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
149 << _T("Quiet:\t") << (parser
.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
155 if ( parser
.Found(_T("o"), &strVal
) )
156 s
<< _T("Output file:\t") << strVal
<< '\n';
157 if ( parser
.Found(_T("i"), &strVal
) )
158 s
<< _T("Input dir:\t") << strVal
<< '\n';
159 if ( parser
.Found(_T("s"), &lVal
) )
160 s
<< _T("Size:\t") << lVal
<< '\n';
161 if ( parser
.Found(_T("f"), &dVal
) )
162 s
<< _T("Double:\t") << dVal
<< '\n';
163 if ( parser
.Found(_T("d"), &dt
) )
164 s
<< _T("Date:\t") << dt
.FormatISODate() << '\n';
165 if ( parser
.Found(_T("project_name"), &strVal
) )
166 s
<< _T("Project:\t") << strVal
<< '\n';
171 #endif // wxUSE_CMDLINE_PARSER
173 static void TestCmdLineConvert()
175 static const wxChar
*cmdlines
[] =
178 _T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
179 _T("literal \\\" and \"\""),
182 for ( size_t n
= 0; n
< WXSIZEOF(cmdlines
); n
++ )
184 const wxChar
*cmdline
= cmdlines
[n
];
185 wxPrintf(_T("Parsing: %s\n"), cmdline
);
186 wxArrayString args
= wxCmdLineParser::ConvertStringToArgs(cmdline
);
188 size_t count
= args
.GetCount();
189 wxPrintf(_T("\targc = %u\n"), count
);
190 for ( size_t arg
= 0; arg
< count
; arg
++ )
192 wxPrintf(_T("\targv[%u] = %s\n"), arg
, args
[arg
].c_str());
197 #endif // TEST_CMDLINE
199 // ----------------------------------------------------------------------------
201 // ----------------------------------------------------------------------------
208 static const wxChar
*ROOTDIR
= _T("/");
209 static const wxChar
*TESTDIR
= _T("/usr/local/share");
210 #elif defined(__WXMSW__) || defined(__DOS__) || defined(__OS2__)
211 static const wxChar
*ROOTDIR
= _T("c:\\");
212 static const wxChar
*TESTDIR
= _T("d:\\");
214 #error "don't know where the root directory is"
217 static void TestDirEnumHelper(wxDir
& dir
,
218 int flags
= wxDIR_DEFAULT
,
219 const wxString
& filespec
= wxEmptyString
)
223 if ( !dir
.IsOpened() )
226 bool cont
= dir
.GetFirst(&filename
, filespec
, flags
);
229 wxPrintf(_T("\t%s\n"), filename
.c_str());
231 cont
= dir
.GetNext(&filename
);
234 wxPuts(wxEmptyString
);
239 static void TestDirEnum()
241 wxPuts(_T("*** Testing wxDir::GetFirst/GetNext ***"));
243 wxString cwd
= wxGetCwd();
244 if ( !wxDir::Exists(cwd
) )
246 wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd
.c_str());
251 if ( !dir
.IsOpened() )
253 wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd
.c_str());
257 wxPuts(_T("Enumerating everything in current directory:"));
258 TestDirEnumHelper(dir
);
260 wxPuts(_T("Enumerating really everything in current directory:"));
261 TestDirEnumHelper(dir
, wxDIR_DEFAULT
| wxDIR_DOTDOT
);
263 wxPuts(_T("Enumerating object files in current directory:"));
264 TestDirEnumHelper(dir
, wxDIR_DEFAULT
, _T("*.o*"));
266 wxPuts(_T("Enumerating directories in current directory:"));
267 TestDirEnumHelper(dir
, wxDIR_DIRS
);
269 wxPuts(_T("Enumerating files in current directory:"));
270 TestDirEnumHelper(dir
, wxDIR_FILES
);
272 wxPuts(_T("Enumerating files including hidden in current directory:"));
273 TestDirEnumHelper(dir
, wxDIR_FILES
| wxDIR_HIDDEN
);
277 wxPuts(_T("Enumerating everything in root directory:"));
278 TestDirEnumHelper(dir
, wxDIR_DEFAULT
);
280 wxPuts(_T("Enumerating directories in root directory:"));
281 TestDirEnumHelper(dir
, wxDIR_DIRS
);
283 wxPuts(_T("Enumerating files in root directory:"));
284 TestDirEnumHelper(dir
, wxDIR_FILES
);
286 wxPuts(_T("Enumerating files including hidden in root directory:"));
287 TestDirEnumHelper(dir
, wxDIR_FILES
| wxDIR_HIDDEN
);
289 wxPuts(_T("Enumerating files in non existing directory:"));
290 wxDir
dirNo(_T("nosuchdir"));
291 TestDirEnumHelper(dirNo
);
296 class DirPrintTraverser
: public wxDirTraverser
299 virtual wxDirTraverseResult
OnFile(const wxString
& WXUNUSED(filename
))
301 return wxDIR_CONTINUE
;
304 virtual wxDirTraverseResult
OnDir(const wxString
& dirname
)
306 wxString path
, name
, ext
;
307 wxSplitPath(dirname
, &path
, &name
, &ext
);
310 name
<< _T('.') << ext
;
313 for ( const wxChar
*p
= path
.c_str(); *p
; p
++ )
315 if ( wxIsPathSeparator(*p
) )
319 wxPrintf(_T("%s%s\n"), indent
.c_str(), name
.c_str());
321 return wxDIR_CONTINUE
;
325 static void TestDirTraverse()
327 wxPuts(_T("*** Testing wxDir::Traverse() ***"));
331 size_t n
= wxDir::GetAllFiles(TESTDIR
, &files
);
332 wxPrintf(_T("There are %u files under '%s'\n"), n
, TESTDIR
);
335 wxPrintf(_T("First one is '%s'\n"), files
[0u].c_str());
336 wxPrintf(_T(" last one is '%s'\n"), files
[n
- 1].c_str());
339 // enum again with custom traverser
340 wxPuts(_T("Now enumerating directories:"));
342 DirPrintTraverser traverser
;
343 dir
.Traverse(traverser
, wxEmptyString
, wxDIR_DIRS
| wxDIR_HIDDEN
);
348 static void TestDirExists()
350 wxPuts(_T("*** Testing wxDir::Exists() ***"));
352 static const wxChar
*dirnames
[] =
355 #if defined(__WXMSW__)
358 _T("\\\\share\\file"),
362 _T("c:\\autoexec.bat"),
363 #elif defined(__UNIX__)
372 for ( size_t n
= 0; n
< WXSIZEOF(dirnames
); n
++ )
374 wxPrintf(_T("%-40s: %s\n"),
376 wxDir::Exists(dirnames
[n
]) ? _T("exists")
377 : _T("doesn't exist"));
385 // ----------------------------------------------------------------------------
387 // ----------------------------------------------------------------------------
391 #include "wx/dynlib.h"
393 static void TestDllLoad()
395 #if defined(__WXMSW__)
396 static const wxChar
*LIB_NAME
= _T("kernel32.dll");
397 static const wxChar
*FUNC_NAME
= _T("lstrlenA");
398 #elif defined(__UNIX__)
399 // weird: using just libc.so does *not* work!
400 static const wxChar
*LIB_NAME
= _T("/lib/libc.so.6");
401 static const wxChar
*FUNC_NAME
= _T("strlen");
403 #error "don't know how to test wxDllLoader on this platform"
406 wxPuts(_T("*** testing basic wxDynamicLibrary functions ***\n"));
408 wxDynamicLibrary
lib(LIB_NAME
);
409 if ( !lib
.IsLoaded() )
411 wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME
);
415 typedef int (wxSTDCALL
*wxStrlenType
)(const char *);
416 wxStrlenType pfnStrlen
= (wxStrlenType
)lib
.GetSymbol(FUNC_NAME
);
419 wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
420 FUNC_NAME
, LIB_NAME
);
424 wxPrintf(_T("Calling %s dynamically loaded from %s "),
425 FUNC_NAME
, LIB_NAME
);
427 if ( pfnStrlen("foo") != 3 )
429 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
433 wxPuts(_T("... ok"));
438 static const wxChar
*FUNC_NAME_AW
= _T("lstrlen");
440 typedef int (wxSTDCALL
*wxStrlenTypeAorW
)(const wxChar
*);
442 pfnStrlenAorW
= (wxStrlenTypeAorW
)lib
.GetSymbolAorW(FUNC_NAME_AW
);
443 if ( !pfnStrlenAorW
)
445 wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
446 FUNC_NAME_AW
, LIB_NAME
);
450 if ( pfnStrlenAorW(_T("foobar")) != 6 )
452 wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
459 #if defined(__WXMSW__) || defined(__UNIX__)
461 static void TestDllListLoaded()
463 wxPuts(_T("*** testing wxDynamicLibrary::ListLoaded() ***\n"));
465 puts("\nLoaded modules:");
466 wxDynamicLibraryDetailsArray dlls
= wxDynamicLibrary::ListLoaded();
467 const size_t count
= dlls
.GetCount();
468 for ( size_t n
= 0; n
< count
; ++n
)
470 const wxDynamicLibraryDetails
& details
= dlls
[n
];
471 printf("%-45s", (const char *)details
.GetPath().mb_str());
475 if ( details
.GetAddress(&addr
, &len
) )
477 printf(" %08lx:%08lx",
478 (unsigned long)addr
, (unsigned long)((char *)addr
+ len
));
481 printf(" %s\n", (const char *)details
.GetVersion().mb_str());
487 #endif // TEST_DYNLIB
489 // ----------------------------------------------------------------------------
491 // ----------------------------------------------------------------------------
495 #include "wx/utils.h"
497 static wxString
MyGetEnv(const wxString
& var
)
500 if ( !wxGetEnv(var
, &val
) )
503 val
= wxString(_T('\'')) + val
+ _T('\'');
508 static void TestEnvironment()
510 const wxChar
*var
= _T("wxTestVar");
512 wxPuts(_T("*** testing environment access functions ***"));
514 wxPrintf(_T("Initially getenv(%s) = %s\n"), var
, MyGetEnv(var
).c_str());
515 wxSetEnv(var
, _T("value for wxTestVar"));
516 wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"), var
, MyGetEnv(var
).c_str());
517 wxSetEnv(var
, _T("another value"));
518 wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"), var
, MyGetEnv(var
).c_str());
520 wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"), var
, MyGetEnv(var
).c_str());
521 wxPrintf(_T("PATH = %s\n"), MyGetEnv(_T("PATH")).c_str());
524 #endif // TEST_ENVIRON
526 // ----------------------------------------------------------------------------
528 // ----------------------------------------------------------------------------
532 #include "wx/utils.h"
534 static void TestExecute()
536 wxPuts(_T("*** testing wxExecute ***"));
539 #define COMMAND "echo hi"
540 #define ASYNC_COMMAND "xclock"
541 #define SHELL_COMMAND "echo hi from shell"
542 #define REDIRECT_COMMAND "cat -n Makefile"
543 #elif defined(__WXMSW__)
544 #define COMMAND "command.com /c echo hi"
545 #define ASYNC_COMMAND "notepad"
546 #define SHELL_COMMAND "echo hi"
547 #define REDIRECT_COMMAND COMMAND
549 #error "no command to exec"
552 wxPrintf(_T("Testing wxShell: "));
554 if ( wxShell(_T(SHELL_COMMAND
)) )
557 wxPuts(_T("ERROR."));
559 wxPrintf(_T("Testing wxExecute: "));
561 if ( wxExecute(_T(COMMAND
), wxEXEC_SYNC
) == 0 )
564 wxPuts(_T("ERROR."));
566 wxPrintf(_T("Testing async wxExecute: "));
568 int pid
= wxExecute(ASYNC_COMMAND
);
571 wxPuts(_T("Ok (command launched)."));
572 if ( wxKill(pid
) == -1 )
573 wxPuts("ERROR: failed to kill child process.");
576 wxPuts(_T("ERROR."));
578 wxPrintf(_T("Testing wxExecute with redirection:\n"));
579 wxArrayString output
;
580 if ( wxExecute(_T(REDIRECT_COMMAND
), output
) != 0 )
582 wxPuts(_T("ERROR."));
586 // don't show too much output, MAX_LINES is enough
587 static const unsigned MAX_LINES
= 20;
589 const unsigned count
= output
.size();
590 for ( unsigned n
= 0;
591 n
< (count
> MAX_LINES
? MAX_LINES
/2 : count
);
594 wxPrintf("%04u:\t%s\n", n
+ 1, output
[n
]);
597 if ( count
> MAX_LINES
)
599 wxPrintf("... skipping %u lines...\n", count
- MAX_LINES
);
601 for ( unsigned n
= count
- MAX_LINES
/2; n
< count
; n
++ )
603 wxPrintf("%04u:\t%s\n", n
+ 1, output
[n
]);
611 #endif // TEST_EXECUTE
613 // ----------------------------------------------------------------------------
615 // ----------------------------------------------------------------------------
620 #include "wx/ffile.h"
621 #include "wx/textfile.h"
623 static void TestFileRead()
625 wxPuts(_T("*** wxFile read test ***"));
627 wxFile
file(_T("testdata.fc"));
628 if ( file
.IsOpened() )
630 wxPrintf(_T("File length: %lu\n"), file
.Length());
632 wxPuts(_T("File dump:\n----------"));
634 static const size_t len
= 1024;
638 size_t nRead
= file
.Read(buf
, len
);
639 if ( nRead
== (size_t)wxInvalidOffset
)
641 wxPrintf(_T("Failed to read the file."));
645 fwrite(buf
, nRead
, 1, stdout
);
651 wxPuts(_T("----------"));
655 wxPrintf(_T("ERROR: can't open test file.\n"));
658 wxPuts(wxEmptyString
);
661 static void TestTextFileRead()
663 wxPuts(_T("*** wxTextFile read test ***"));
665 wxTextFile
file(_T("testdata.fc"));
668 wxPrintf(_T("Number of lines: %u\n"), file
.GetLineCount());
669 wxPrintf(_T("Last line: '%s'\n"), file
.GetLastLine().c_str());
673 wxPuts(_T("\nDumping the entire file:"));
674 for ( s
= file
.GetFirstLine(); !file
.Eof(); s
= file
.GetNextLine() )
676 wxPrintf(_T("%6u: %s\n"), file
.GetCurrentLine() + 1, s
.c_str());
678 wxPrintf(_T("%6u: %s\n"), file
.GetCurrentLine() + 1, s
.c_str());
680 wxPuts(_T("\nAnd now backwards:"));
681 for ( s
= file
.GetLastLine();
682 file
.GetCurrentLine() != 0;
683 s
= file
.GetPrevLine() )
685 wxPrintf(_T("%6u: %s\n"), file
.GetCurrentLine() + 1, s
.c_str());
687 wxPrintf(_T("%6u: %s\n"), file
.GetCurrentLine() + 1, s
.c_str());
691 wxPrintf(_T("ERROR: can't open '%s'\n"), file
.GetName());
694 wxPuts(wxEmptyString
);
697 static void TestFileCopy()
699 wxPuts(_T("*** Testing wxCopyFile ***"));
701 static const wxChar
*filename1
= _T("testdata.fc");
702 static const wxChar
*filename2
= _T("test2");
703 if ( !wxCopyFile(filename1
, filename2
) )
705 wxPuts(_T("ERROR: failed to copy file"));
709 wxFFile
f1(filename1
, _T("rb")),
710 f2(filename2
, _T("rb"));
712 if ( !f1
.IsOpened() || !f2
.IsOpened() )
714 wxPuts(_T("ERROR: failed to open file(s)"));
719 if ( !f1
.ReadAll(&s1
) || !f2
.ReadAll(&s2
) )
721 wxPuts(_T("ERROR: failed to read file(s)"));
725 if ( (s1
.length() != s2
.length()) ||
726 (memcmp(s1
.c_str(), s2
.c_str(), s1
.length()) != 0) )
728 wxPuts(_T("ERROR: copy error!"));
732 wxPuts(_T("File was copied ok."));
738 if ( !wxRemoveFile(filename2
) )
740 wxPuts(_T("ERROR: failed to remove the file"));
743 wxPuts(wxEmptyString
);
746 static void TestTempFile()
748 wxPuts(_T("*** wxTempFile test ***"));
751 if ( tmpFile
.Open(_T("test2")) && tmpFile
.Write(_T("the answer is 42")) )
753 if ( tmpFile
.Commit() )
754 wxPuts(_T("File committed."));
756 wxPuts(_T("ERROR: could't commit temp file."));
758 wxRemoveFile(_T("test2"));
761 wxPuts(wxEmptyString
);
766 // ----------------------------------------------------------------------------
768 // ----------------------------------------------------------------------------
772 #include "wx/confbase.h"
773 #include "wx/fileconf.h"
775 static const struct FileConfTestData
777 const wxChar
*name
; // value name
778 const wxChar
*value
; // the value from the file
781 { _T("value1"), _T("one") },
782 { _T("value2"), _T("two") },
783 { _T("novalue"), _T("default") },
786 static void TestFileConfRead()
788 wxPuts(_T("*** testing wxFileConfig loading/reading ***"));
790 wxFileConfig
fileconf(_T("test"), wxEmptyString
,
791 _T("testdata.fc"), wxEmptyString
,
792 wxCONFIG_USE_RELATIVE_PATH
);
794 // test simple reading
795 wxPuts(_T("\nReading config file:"));
796 wxString
defValue(_T("default")), value
;
797 for ( size_t n
= 0; n
< WXSIZEOF(fcTestData
); n
++ )
799 const FileConfTestData
& data
= fcTestData
[n
];
800 value
= fileconf
.Read(data
.name
, defValue
);
801 wxPrintf(_T("\t%s = %s "), data
.name
, value
.c_str());
802 if ( value
== data
.value
)
808 wxPrintf(_T("(ERROR: should be %s)\n"), data
.value
);
812 // test enumerating the entries
813 wxPuts(_T("\nEnumerating all root entries:"));
816 bool cont
= fileconf
.GetFirstEntry(name
, dummy
);
819 wxPrintf(_T("\t%s = %s\n"),
821 fileconf
.Read(name
.c_str(), _T("ERROR")).c_str());
823 cont
= fileconf
.GetNextEntry(name
, dummy
);
826 static const wxChar
*testEntry
= _T("TestEntry");
827 wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
828 fileconf
.Write(testEntry
, _T("A value"));
829 fileconf
.DeleteEntry(testEntry
);
830 wxPrintf(fileconf
.HasEntry(testEntry
) ? _T("ERROR\n") : _T("ok\n"));
833 #endif // TEST_FILECONF
835 // ----------------------------------------------------------------------------
837 // ----------------------------------------------------------------------------
841 #include "wx/filename.h"
844 static void DumpFileName(const wxChar
*desc
, const wxFileName
& fn
)
848 wxString full
= fn
.GetFullPath();
850 wxString vol
, path
, name
, ext
;
851 wxFileName::SplitPath(full
, &vol
, &path
, &name
, &ext
);
853 wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
854 full
.c_str(), vol
.c_str(), path
.c_str(), name
.c_str(), ext
.c_str());
856 wxFileName::SplitPath(full
, &path
, &name
, &ext
);
857 wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
858 path
.c_str(), name
.c_str(), ext
.c_str());
860 wxPrintf(_T("path is also:\t'%s'\n"), fn
.GetPath().c_str());
861 wxPrintf(_T("with volume: \t'%s'\n"),
862 fn
.GetPath(wxPATH_GET_VOLUME
).c_str());
863 wxPrintf(_T("with separator:\t'%s'\n"),
864 fn
.GetPath(wxPATH_GET_SEPARATOR
).c_str());
865 wxPrintf(_T("with both: \t'%s'\n"),
866 fn
.GetPath(wxPATH_GET_SEPARATOR
| wxPATH_GET_VOLUME
).c_str());
868 wxPuts(_T("The directories in the path are:"));
869 wxArrayString dirs
= fn
.GetDirs();
870 size_t count
= dirs
.GetCount();
871 for ( size_t n
= 0; n
< count
; n
++ )
873 wxPrintf(_T("\t%u: %s\n"), n
, dirs
[n
].c_str());
878 static void TestFileNameTemp()
880 wxPuts(_T("*** testing wxFileName temp file creation ***"));
882 static const wxChar
*tmpprefixes
[] =
890 _T("/tmp/foo/bar"), // this one must be an error
894 for ( size_t n
= 0; n
< WXSIZEOF(tmpprefixes
); n
++ )
896 wxString path
= wxFileName::CreateTempFileName(tmpprefixes
[n
]);
899 // "error" is not in upper case because it may be ok
900 wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes
[n
]);
904 wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
905 tmpprefixes
[n
], path
.c_str());
907 if ( !wxRemoveFile(path
) )
909 wxLogWarning(_T("Failed to remove temp file '%s'"),
916 static void TestFileNameDirManip()
918 // TODO: test AppendDir(), RemoveDir(), ...
921 static void TestFileNameComparison()
926 static void TestFileNameOperations()
931 static void TestFileNameCwd()
936 #endif // TEST_FILENAME
938 // ----------------------------------------------------------------------------
939 // wxFileName time functions
940 // ----------------------------------------------------------------------------
944 #include "wx/filename.h"
945 #include "wx/datetime.h"
947 static void TestFileGetTimes()
949 wxFileName
fn(_T("testdata.fc"));
951 wxDateTime dtAccess
, dtMod
, dtCreate
;
952 if ( !fn
.GetTimes(&dtAccess
, &dtMod
, &dtCreate
) )
954 wxPrintf(_T("ERROR: GetTimes() failed.\n"));
958 static const wxChar
*fmt
= _T("%Y-%b-%d %H:%M:%S");
960 wxPrintf(_T("File times for '%s':\n"), fn
.GetFullPath().c_str());
961 wxPrintf(_T("Creation: \t%s\n"), dtCreate
.Format(fmt
).c_str());
962 wxPrintf(_T("Last read: \t%s\n"), dtAccess
.Format(fmt
).c_str());
963 wxPrintf(_T("Last write: \t%s\n"), dtMod
.Format(fmt
).c_str());
968 static void TestFileSetTimes()
970 wxFileName
fn(_T("testdata.fc"));
974 wxPrintf(_T("ERROR: Touch() failed.\n"));
979 #endif // TEST_FILETIME
981 // ----------------------------------------------------------------------------
983 // ----------------------------------------------------------------------------
988 #include "wx/utils.h" // for wxSetEnv
990 static wxLocale gs_localeDefault
;
991 // NOTE: don't init it here as it needs a wxAppTraits object
992 // and thus must be init-ed after creation of the wxInitializer
993 // class in the main()
995 // find the name of the language from its value
996 static const wxChar
*GetLangName(int lang
)
998 static const wxChar
*languageNames
[] =
1008 _T("ARABIC_ALGERIA"),
1009 _T("ARABIC_BAHRAIN"),
1012 _T("ARABIC_JORDAN"),
1013 _T("ARABIC_KUWAIT"),
1014 _T("ARABIC_LEBANON"),
1016 _T("ARABIC_MOROCCO"),
1019 _T("ARABIC_SAUDI_ARABIA"),
1022 _T("ARABIC_TUNISIA"),
1029 _T("AZERI_CYRILLIC"),
1044 _T("CHINESE_SIMPLIFIED"),
1045 _T("CHINESE_TRADITIONAL"),
1046 _T("CHINESE_HONGKONG"),
1047 _T("CHINESE_MACAU"),
1048 _T("CHINESE_SINGAPORE"),
1049 _T("CHINESE_TAIWAN"),
1055 _T("DUTCH_BELGIAN"),
1059 _T("ENGLISH_AUSTRALIA"),
1060 _T("ENGLISH_BELIZE"),
1061 _T("ENGLISH_BOTSWANA"),
1062 _T("ENGLISH_CANADA"),
1063 _T("ENGLISH_CARIBBEAN"),
1064 _T("ENGLISH_DENMARK"),
1066 _T("ENGLISH_JAMAICA"),
1067 _T("ENGLISH_NEW_ZEALAND"),
1068 _T("ENGLISH_PHILIPPINES"),
1069 _T("ENGLISH_SOUTH_AFRICA"),
1070 _T("ENGLISH_TRINIDAD"),
1071 _T("ENGLISH_ZIMBABWE"),
1079 _T("FRENCH_BELGIAN"),
1080 _T("FRENCH_CANADIAN"),
1081 _T("FRENCH_LUXEMBOURG"),
1082 _T("FRENCH_MONACO"),
1088 _T("GERMAN_AUSTRIAN"),
1089 _T("GERMAN_BELGIUM"),
1090 _T("GERMAN_LIECHTENSTEIN"),
1091 _T("GERMAN_LUXEMBOURG"),
1109 _T("ITALIAN_SWISS"),
1114 _T("KASHMIRI_INDIA"),
1132 _T("MALAY_BRUNEI_DARUSSALAM"),
1133 _T("MALAY_MALAYSIA"),
1143 _T("NORWEGIAN_BOKMAL"),
1144 _T("NORWEGIAN_NYNORSK"),
1151 _T("PORTUGUESE_BRAZILIAN"),
1154 _T("RHAETO_ROMANCE"),
1157 _T("RUSSIAN_UKRAINE"),
1163 _T("SERBIAN_CYRILLIC"),
1164 _T("SERBIAN_LATIN"),
1165 _T("SERBO_CROATIAN"),
1176 _T("SPANISH_ARGENTINA"),
1177 _T("SPANISH_BOLIVIA"),
1178 _T("SPANISH_CHILE"),
1179 _T("SPANISH_COLOMBIA"),
1180 _T("SPANISH_COSTA_RICA"),
1181 _T("SPANISH_DOMINICAN_REPUBLIC"),
1182 _T("SPANISH_ECUADOR"),
1183 _T("SPANISH_EL_SALVADOR"),
1184 _T("SPANISH_GUATEMALA"),
1185 _T("SPANISH_HONDURAS"),
1186 _T("SPANISH_MEXICAN"),
1187 _T("SPANISH_MODERN"),
1188 _T("SPANISH_NICARAGUA"),
1189 _T("SPANISH_PANAMA"),
1190 _T("SPANISH_PARAGUAY"),
1192 _T("SPANISH_PUERTO_RICO"),
1193 _T("SPANISH_URUGUAY"),
1195 _T("SPANISH_VENEZUELA"),
1199 _T("SWEDISH_FINLAND"),
1217 _T("URDU_PAKISTAN"),
1219 _T("UZBEK_CYRILLIC"),
1232 if ( (size_t)lang
< WXSIZEOF(languageNames
) )
1233 return languageNames
[lang
];
1235 return _T("INVALID");
1238 static void TestDefaultLang()
1240 wxPuts(_T("*** Testing wxLocale::GetSystemLanguage ***"));
1242 gs_localeDefault
.Init(wxLANGUAGE_ENGLISH
);
1244 static const wxChar
*langStrings
[] =
1246 NULL
, // system default
1253 _T("de_DE.iso88591"),
1255 _T("?"), // invalid lang spec
1256 _T("klingonese"), // I bet on some systems it does exist...
1259 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1260 wxLocale::GetSystemEncodingName().c_str(),
1261 wxLocale::GetSystemEncoding());
1263 for ( size_t n
= 0; n
< WXSIZEOF(langStrings
); n
++ )
1265 const wxChar
*langStr
= langStrings
[n
];
1268 // FIXME: this doesn't do anything at all under Windows, we need
1269 // to create a new wxLocale!
1270 wxSetEnv(_T("LC_ALL"), langStr
);
1273 int lang
= gs_localeDefault
.GetSystemLanguage();
1274 wxPrintf(_T("Locale for '%s' is %s.\n"),
1275 langStr
? langStr
: _T("system default"), GetLangName(lang
));
1279 #endif // TEST_LOCALE
1281 // ----------------------------------------------------------------------------
1283 // ----------------------------------------------------------------------------
1287 #include "wx/mimetype.h"
1289 static void TestMimeEnum()
1291 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1293 wxArrayString mimetypes
;
1295 size_t count
= wxTheMimeTypesManager
->EnumAllFileTypes(mimetypes
);
1297 wxPrintf(_T("*** All %u known filetypes: ***\n"), count
);
1302 for ( size_t n
= 0; n
< count
; n
++ )
1304 wxFileType
*filetype
=
1305 wxTheMimeTypesManager
->GetFileTypeFromMimeType(mimetypes
[n
]);
1308 wxPrintf(_T("nothing known about the filetype '%s'!\n"),
1309 mimetypes
[n
].c_str());
1313 filetype
->GetDescription(&desc
);
1314 filetype
->GetExtensions(exts
);
1316 filetype
->GetIcon(NULL
);
1319 for ( size_t e
= 0; e
< exts
.GetCount(); e
++ )
1322 extsAll
<< _T(", ");
1326 wxPrintf(_T("\t%s: %s (%s)\n"),
1327 mimetypes
[n
].c_str(), desc
.c_str(), extsAll
.c_str());
1330 wxPuts(wxEmptyString
);
1333 static void TestMimeFilename()
1335 wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1337 static const wxChar
*filenames
[] =
1345 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
1347 const wxString fname
= filenames
[n
];
1348 wxString ext
= fname
.AfterLast(_T('.'));
1349 wxFileType
*ft
= wxTheMimeTypesManager
->GetFileTypeFromExtension(ext
);
1352 wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext
.c_str());
1357 if ( !ft
->GetDescription(&desc
) )
1358 desc
= _T("<no description>");
1361 if ( !ft
->GetOpenCommand(&cmd
,
1362 wxFileType::MessageParameters(fname
, wxEmptyString
)) )
1363 cmd
= _T("<no command available>");
1365 cmd
= wxString(_T('"')) + cmd
+ _T('"');
1367 wxPrintf(_T("To open %s (%s) do %s.\n"),
1368 fname
.c_str(), desc
.c_str(), cmd
.c_str());
1374 wxPuts(wxEmptyString
);
1377 // these tests were broken by wxMimeTypesManager changes, temporarily disabling
1380 static void TestMimeOverride()
1382 wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1384 static const wxChar
*mailcap
= _T("/tmp/mailcap");
1385 static const wxChar
*mimetypes
= _T("/tmp/mime.types");
1387 if ( wxFile::Exists(mailcap
) )
1388 wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1390 wxTheMimeTypesManager
->ReadMailcap(mailcap
) ? _T("ok") : _T("ERROR"));
1392 wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1395 if ( wxFile::Exists(mimetypes
) )
1396 wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1398 wxTheMimeTypesManager
->ReadMimeTypes(mimetypes
) ? _T("ok") : _T("ERROR"));
1400 wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1403 wxPuts(wxEmptyString
);
1406 static void TestMimeAssociate()
1408 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1410 wxFileTypeInfo
ftInfo(
1411 _T("application/x-xyz"),
1412 _T("xyzview '%s'"), // open cmd
1413 _T(""), // print cmd
1414 _T("XYZ File"), // description
1415 _T(".xyz"), // extensions
1416 wxNullPtr
// end of extensions
1418 ftInfo
.SetShortDesc(_T("XYZFile")); // used under Win32 only
1420 wxFileType
*ft
= wxTheMimeTypesManager
->Associate(ftInfo
);
1423 wxPuts(_T("ERROR: failed to create association!"));
1427 // TODO: read it back
1431 wxPuts(wxEmptyString
);
1438 // ----------------------------------------------------------------------------
1439 // module dependencies feature
1440 // ----------------------------------------------------------------------------
1444 #include "wx/module.h"
1446 class wxTestModule
: public wxModule
1449 virtual bool OnInit() { wxPrintf(_T("Load module: %s\n"), GetClassInfo()->GetClassName()); return true; }
1450 virtual void OnExit() { wxPrintf(_T("Unload module: %s\n"), GetClassInfo()->GetClassName()); }
1453 class wxTestModuleA
: public wxTestModule
1458 DECLARE_DYNAMIC_CLASS(wxTestModuleA
)
1461 class wxTestModuleB
: public wxTestModule
1466 DECLARE_DYNAMIC_CLASS(wxTestModuleB
)
1469 class wxTestModuleC
: public wxTestModule
1474 DECLARE_DYNAMIC_CLASS(wxTestModuleC
)
1477 class wxTestModuleD
: public wxTestModule
1482 DECLARE_DYNAMIC_CLASS(wxTestModuleD
)
1485 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleC
, wxModule
)
1486 wxTestModuleC::wxTestModuleC()
1488 AddDependency(CLASSINFO(wxTestModuleD
));
1491 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleA
, wxModule
)
1492 wxTestModuleA::wxTestModuleA()
1494 AddDependency(CLASSINFO(wxTestModuleB
));
1495 AddDependency(CLASSINFO(wxTestModuleD
));
1498 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleD
, wxModule
)
1499 wxTestModuleD::wxTestModuleD()
1503 IMPLEMENT_DYNAMIC_CLASS(wxTestModuleB
, wxModule
)
1504 wxTestModuleB::wxTestModuleB()
1506 AddDependency(CLASSINFO(wxTestModuleD
));
1507 AddDependency(CLASSINFO(wxTestModuleC
));
1510 #endif // TEST_MODULE
1512 // ----------------------------------------------------------------------------
1513 // misc information functions
1514 // ----------------------------------------------------------------------------
1516 #ifdef TEST_INFO_FUNCTIONS
1518 #include "wx/utils.h"
1520 #if TEST_INTERACTIVE
1521 static void TestDiskInfo()
1523 wxPuts(_T("*** Testing wxGetDiskSpace() ***"));
1527 wxChar pathname
[128];
1528 wxPrintf(_T("\nEnter a directory name: "));
1529 if ( !wxFgets(pathname
, WXSIZEOF(pathname
), stdin
) )
1532 // kill the last '\n'
1533 pathname
[wxStrlen(pathname
) - 1] = 0;
1535 wxLongLong total
, free
;
1536 if ( !wxGetDiskSpace(pathname
, &total
, &free
) )
1538 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1542 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1543 (total
/ 1024).ToString().c_str(),
1544 (free
/ 1024).ToString().c_str(),
1549 #endif // TEST_INTERACTIVE
1551 static void TestOsInfo()
1553 wxPuts(_T("*** Testing OS info functions ***\n"));
1556 wxGetOsVersion(&major
, &minor
);
1557 wxPrintf(_T("Running under: %s, version %d.%d\n"),
1558 wxGetOsDescription().c_str(), major
, minor
);
1560 wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());
1562 wxPrintf(_T("Host name is %s (%s).\n"),
1563 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1565 wxPuts(wxEmptyString
);
1568 static void TestPlatformInfo()
1570 wxPuts(_T("*** Testing wxPlatformInfo functions ***\n"));
1572 // get this platform
1573 wxPlatformInfo plat
;
1575 wxPrintf(_T("Operating system family name is: %s\n"), plat
.GetOperatingSystemFamilyName().c_str());
1576 wxPrintf(_T("Operating system name is: %s\n"), plat
.GetOperatingSystemIdName().c_str());
1577 wxPrintf(_T("Port ID name is: %s\n"), plat
.GetPortIdName().c_str());
1578 wxPrintf(_T("Port ID short name is: %s\n"), plat
.GetPortIdShortName().c_str());
1579 wxPrintf(_T("Architecture is: %s\n"), plat
.GetArchName().c_str());
1580 wxPrintf(_T("Endianness is: %s\n"), plat
.GetEndiannessName().c_str());
1582 wxPuts(wxEmptyString
);
1585 static void TestUserInfo()
1587 wxPuts(_T("*** Testing user info functions ***\n"));
1589 wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
1590 wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
1591 wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
1592 wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
1594 wxPuts(wxEmptyString
);
1597 #endif // TEST_INFO_FUNCTIONS
1599 // ----------------------------------------------------------------------------
1601 // ----------------------------------------------------------------------------
1603 #ifdef TEST_PATHLIST
1606 #define CMD_IN_PATH _T("ls")
1608 #define CMD_IN_PATH _T("command.com")
1611 static void TestPathList()
1613 wxPuts(_T("*** Testing wxPathList ***\n"));
1615 wxPathList pathlist
;
1616 pathlist
.AddEnvList(_T("PATH"));
1617 wxString path
= pathlist
.FindValidPath(CMD_IN_PATH
);
1620 wxPrintf(_T("ERROR: command not found in the path.\n"));
1624 wxPrintf(_T("Command found in the path as '%s'.\n"), path
.c_str());
1628 #endif // TEST_PATHLIST
1630 // ----------------------------------------------------------------------------
1631 // regular expressions
1632 // ----------------------------------------------------------------------------
1636 #include "wx/regex.h"
1638 static void TestRegExInteractive()
1640 wxPuts(_T("*** Testing RE interactively ***"));
1644 wxChar pattern
[128];
1645 wxPrintf(_T("\nEnter a pattern: "));
1646 if ( !wxFgets(pattern
, WXSIZEOF(pattern
), stdin
) )
1649 // kill the last '\n'
1650 pattern
[wxStrlen(pattern
) - 1] = 0;
1653 if ( !re
.Compile(pattern
) )
1661 wxPrintf(_T("Enter text to match: "));
1662 if ( !wxFgets(text
, WXSIZEOF(text
), stdin
) )
1665 // kill the last '\n'
1666 text
[wxStrlen(text
) - 1] = 0;
1668 if ( !re
.Matches(text
) )
1670 wxPrintf(_T("No match.\n"));
1674 wxPrintf(_T("Pattern matches at '%s'\n"), re
.GetMatch(text
).c_str());
1677 for ( size_t n
= 1; ; n
++ )
1679 if ( !re
.GetMatch(&start
, &len
, n
) )
1684 wxPrintf(_T("Subexpr %u matched '%s'\n"),
1685 n
, wxString(text
+ start
, len
).c_str());
1692 #endif // TEST_REGEX
1694 // ----------------------------------------------------------------------------
1696 // ----------------------------------------------------------------------------
1699 NB: this stuff was taken from the glibc test suite and modified to build
1700 in wxWidgets: if I read the copyright below properly, this shouldn't
1706 #ifdef wxTEST_PRINTF
1707 // use our functions from wxchar.cpp
1711 // NB: do _not_ use ATTRIBUTE_PRINTF here, we have some invalid formats
1712 // in the tests below
1713 int wxPrintf( const wxChar
*format
, ... );
1714 int wxSprintf( wxChar
*str
, const wxChar
*format
, ... );
1717 #include "wx/longlong.h"
1721 static void rfg1 (void);
1722 static void rfg2 (void);
1726 fmtchk (const wxChar
*fmt
)
1728 (void) wxPrintf(_T("%s:\t`"), fmt
);
1729 (void) wxPrintf(fmt
, 0x12);
1730 (void) wxPrintf(_T("'\n"));
1734 fmtst1chk (const wxChar
*fmt
)
1736 (void) wxPrintf(_T("%s:\t`"), fmt
);
1737 (void) wxPrintf(fmt
, 4, 0x12);
1738 (void) wxPrintf(_T("'\n"));
1742 fmtst2chk (const wxChar
*fmt
)
1744 (void) wxPrintf(_T("%s:\t`"), fmt
);
1745 (void) wxPrintf(fmt
, 4, 4, 0x12);
1746 (void) wxPrintf(_T("'\n"));
1749 /* This page is covered by the following copyright: */
1751 /* (C) Copyright C E Chew
1753 * Feel free to copy, use and distribute this software provided:
1755 * 1. you do not pretend that you wrote it
1756 * 2. you leave this copyright notice intact.
1760 * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
1767 /* Formatted Output Test
1769 * This exercises the output formatting code.
1772 wxChar
*PointerNull
= NULL
;
1779 wxChar
*prefix
= buf
;
1782 wxPuts(_T("\nFormatted output test"));
1783 wxPrintf(_T("prefix 6d 6o 6x 6X 6u\n"));
1784 wxStrcpy(prefix
, _T("%"));
1785 for (i
= 0; i
< 2; i
++) {
1786 for (j
= 0; j
< 2; j
++) {
1787 for (k
= 0; k
< 2; k
++) {
1788 for (l
= 0; l
< 2; l
++) {
1789 wxStrcpy(prefix
, _T("%"));
1790 if (i
== 0) wxStrcat(prefix
, _T("-"));
1791 if (j
== 0) wxStrcat(prefix
, _T("+"));
1792 if (k
== 0) wxStrcat(prefix
, _T("#"));
1793 if (l
== 0) wxStrcat(prefix
, _T("0"));
1794 wxPrintf(_T("%5s |"), prefix
);
1795 wxStrcpy(tp
, prefix
);
1796 wxStrcat(tp
, _T("6d |"));
1798 wxStrcpy(tp
, prefix
);
1799 wxStrcat(tp
, _T("6o |"));
1801 wxStrcpy(tp
, prefix
);
1802 wxStrcat(tp
, _T("6x |"));
1804 wxStrcpy(tp
, prefix
);
1805 wxStrcat(tp
, _T("6X |"));
1807 wxStrcpy(tp
, prefix
);
1808 wxStrcat(tp
, _T("6u |"));
1815 wxPrintf(_T("%10s\n"), PointerNull
);
1816 wxPrintf(_T("%-10s\n"), PointerNull
);
1819 static void TestPrintf()
1821 static wxChar shortstr
[] = _T("Hi, Z.");
1822 static wxChar longstr
[] = _T("Good morning, Doctor Chandra. This is Hal. \
1823 I am ready for my first lesson today.");
1825 wxString test_format
;
1829 fmtchk(_T("%4.4x"));
1830 fmtchk(_T("%04.4x"));
1831 fmtchk(_T("%4.3x"));
1832 fmtchk(_T("%04.3x"));
1834 fmtst1chk(_T("%.*x"));
1835 fmtst1chk(_T("%0*x"));
1836 fmtst2chk(_T("%*.*x"));
1837 fmtst2chk(_T("%0*.*x"));
1839 wxString bad_format
= _T("bad format:\t\"%b\"\n");
1840 wxPrintf(bad_format
.c_str());
1841 wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL
);
1843 wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
1844 wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
1845 wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
1846 wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
1847 wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
1848 wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
1849 wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
1850 test_format
= _T("left-adjusted ZLDN:\t\"%-010ld\"\n");
1851 wxPrintf(test_format
.c_str(), -123456);
1852 wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
1853 wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
1855 test_format
= _T("zero-padded string:\t\"%010s\"\n");
1856 wxPrintf(test_format
.c_str(), shortstr
);
1857 test_format
= _T("left-adjusted Z string:\t\"%-010s\"\n");
1858 wxPrintf(test_format
.c_str(), shortstr
);
1859 wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr
);
1860 wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr
);
1861 wxPrintf(_T("null string:\t\"%s\"\n"), PointerNull
);
1862 wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr
);
1864 wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
1865 wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
1866 wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
1867 wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20
);
1868 wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
1869 wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
1870 wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
1871 wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
1872 wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
1873 wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
1874 wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
1875 wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20
);
1877 wxPrintf (_T(" %6.5f\n"), .099999999860301614);
1878 wxPrintf (_T(" %6.5f\n"), .1);
1879 wxPrintf (_T("x%5.4fx\n"), .5);
1881 wxPrintf (_T("%#03x\n"), 1);
1883 //wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
1889 while (niter
-- != 0)
1890 wxPrintf (_T("%.17e\n"), d
/ 2);
1895 // Open Watcom cause compiler error here
1896 // Error! E173: col(24) floating-point constant too small to represent
1897 wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
1900 #define FORMAT _T("|%12.4f|%12.4e|%12.4g|\n")
1901 wxPrintf (FORMAT
, 0.0, 0.0, 0.0);
1902 wxPrintf (FORMAT
, 1.0, 1.0, 1.0);
1903 wxPrintf (FORMAT
, -1.0, -1.0, -1.0);
1904 wxPrintf (FORMAT
, 100.0, 100.0, 100.0);
1905 wxPrintf (FORMAT
, 1000.0, 1000.0, 1000.0);
1906 wxPrintf (FORMAT
, 10000.0, 10000.0, 10000.0);
1907 wxPrintf (FORMAT
, 12345.0, 12345.0, 12345.0);
1908 wxPrintf (FORMAT
, 100000.0, 100000.0, 100000.0);
1909 wxPrintf (FORMAT
, 123456.0, 123456.0, 123456.0);
1914 int rc
= wxSnprintf (buf
, WXSIZEOF(buf
), _T("%30s"), _T("foo"));
1916 wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
1917 rc
, WXSIZEOF(buf
), buf
);
1920 wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
1921 wxSnprintf(buf2
, WXSIZEOFbuf2
), "%.999999u", 10));
1927 wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
1928 wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
1929 wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
1930 wxPrintf (_T("%g should be 123.456\n"), 123.456);
1931 wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
1932 wxPrintf (_T("%g should be 10\n"), 10.0);
1933 wxPrintf (_T("%g should be 0.02\n"), 0.02);
1937 wxPrintf(_T("%.17f\n"),(1.0/x
/10.0+1.0)*x
-x
);
1943 wxSprintf(buf
,_T("%*s%*s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
1945 result
|= wxStrcmp (buf
,
1946 _T("onetwo three "));
1948 wxPuts (result
!= 0 ? _T("Test failed!") : _T("Test ok."));
1955 wxSprintf(buf
, _T("%07") wxLongLongFmtSpec
_T("o"), wxLL(040000000000));
1957 // for some reason below line fails under Borland
1958 wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf
);
1961 if (wxStrcmp (buf
, _T("40000000000")) != 0)
1964 wxPuts (_T("\tFAILED"));
1966 wxUnusedVar(result
);
1967 wxPuts (wxEmptyString
);
1969 #endif // wxLongLong_t
1971 wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX
+ 2, UCHAR_MAX
+ 2);
1972 wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX
+ 2, USHRT_MAX
+ 2);
1974 wxPuts (_T("--- Should be no further output. ---"));
1983 memset (bytes
, '\xff', sizeof bytes
);
1984 wxSprintf (buf
, _T("foo%hhn\n"), &bytes
[3]);
1985 if (bytes
[0] != '\xff' || bytes
[1] != '\xff' || bytes
[2] != '\xff'
1986 || bytes
[4] != '\xff' || bytes
[5] != '\xff' || bytes
[6] != '\xff')
1988 wxPuts (_T("%hhn overwrite more bytes"));
1993 wxPuts (_T("%hhn wrote incorrect value"));
2005 wxSprintf (buf
, _T("%5.s"), _T("xyz"));
2006 if (wxStrcmp (buf
, _T(" ")) != 0)
2007 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" "));
2008 wxSprintf (buf
, _T("%5.f"), 33.3);
2009 if (wxStrcmp (buf
, _T(" 33")) != 0)
2010 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 33"));
2011 wxSprintf (buf
, _T("%8.e"), 33.3e7
);
2012 if (wxStrcmp (buf
, _T(" 3e+08")) != 0)
2013 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 3e+08"));
2014 wxSprintf (buf
, _T("%8.E"), 33.3e7
);
2015 if (wxStrcmp (buf
, _T(" 3E+08")) != 0)
2016 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 3E+08"));
2017 wxSprintf (buf
, _T("%.g"), 33.3);
2018 if (wxStrcmp (buf
, _T("3e+01")) != 0)
2019 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T("3e+01"));
2020 wxSprintf (buf
, _T("%.G"), 33.3);
2021 if (wxStrcmp (buf
, _T("3E+01")) != 0)
2022 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T("3E+01"));
2030 wxString test_format
;
2033 wxSprintf (buf
, _T("%.*g"), prec
, 3.3);
2034 if (wxStrcmp (buf
, _T("3")) != 0)
2035 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T("3"));
2037 wxSprintf (buf
, _T("%.*G"), prec
, 3.3);
2038 if (wxStrcmp (buf
, _T("3")) != 0)
2039 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T("3"));
2041 wxSprintf (buf
, _T("%7.*G"), prec
, 3.33);
2042 if (wxStrcmp (buf
, _T(" 3")) != 0)
2043 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 3"));
2045 test_format
= _T("%04.*o");
2046 wxSprintf (buf
, test_format
.c_str(), prec
, 33);
2047 if (wxStrcmp (buf
, _T(" 041")) != 0)
2048 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 041"));
2050 test_format
= _T("%09.*u");
2051 wxSprintf (buf
, test_format
.c_str(), prec
, 33);
2052 if (wxStrcmp (buf
, _T(" 0000033")) != 0)
2053 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 0000033"));
2055 test_format
= _T("%04.*x");
2056 wxSprintf (buf
, test_format
.c_str(), prec
, 33);
2057 if (wxStrcmp (buf
, _T(" 021")) != 0)
2058 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 021"));
2060 test_format
= _T("%04.*X");
2061 wxSprintf (buf
, test_format
.c_str(), prec
, 33);
2062 if (wxStrcmp (buf
, _T(" 021")) != 0)
2063 wxPrintf (_T("got: '%s', expected: '%s'\n"), buf
, _T(" 021"));
2066 #endif // TEST_PRINTF
2068 // ----------------------------------------------------------------------------
2069 // registry and related stuff
2070 // ----------------------------------------------------------------------------
2072 // this is for MSW only
2075 #undef TEST_REGISTRY
2080 #include "wx/confbase.h"
2081 #include "wx/msw/regconf.h"
2084 static void TestRegConfWrite()
2086 wxConfig
*config
= new wxConfig(_T("myapp"));
2087 config
->SetPath(_T("/group1"));
2088 config
->Write(_T("entry1"), _T("foo"));
2089 config
->SetPath(_T("/group2"));
2090 config
->Write(_T("entry1"), _T("bar"));
2094 static void TestRegConfRead()
2096 wxRegConfig
*config
= new wxRegConfig(_T("myapp"));
2100 config
->SetPath(_T("/"));
2101 wxPuts(_T("Enumerating / subgroups:"));
2102 bool bCont
= config
->GetFirstGroup(str
, dummy
);
2106 bCont
= config
->GetNextGroup(str
, dummy
);
2110 #endif // TEST_REGCONF
2112 #ifdef TEST_REGISTRY
2114 #include "wx/msw/registry.h"
2116 // I chose this one because I liked its name, but it probably only exists under
2118 static const wxChar
*TESTKEY
=
2119 _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2121 static void TestRegistryRead()
2123 wxPuts(_T("*** testing registry reading ***"));
2125 wxRegKey
key(TESTKEY
);
2126 wxPrintf(_T("The test key name is '%s'.\n"), key
.GetName().c_str());
2129 wxPuts(_T("ERROR: test key can't be opened, aborting test."));
2134 size_t nSubKeys
, nValues
;
2135 if ( key
.GetKeyInfo(&nSubKeys
, NULL
, &nValues
, NULL
) )
2137 wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys
, nValues
);
2140 wxPrintf(_T("Enumerating values:\n"));
2144 bool cont
= key
.GetFirstValue(value
, dummy
);
2147 wxPrintf(_T("Value '%s': type "), value
.c_str());
2148 switch ( key
.GetValueType(value
) )
2150 case wxRegKey::Type_None
: wxPrintf(_T("ERROR (none)")); break;
2151 case wxRegKey::Type_String
: wxPrintf(_T("SZ")); break;
2152 case wxRegKey::Type_Expand_String
: wxPrintf(_T("EXPAND_SZ")); break;
2153 case wxRegKey::Type_Binary
: wxPrintf(_T("BINARY")); break;
2154 case wxRegKey::Type_Dword
: wxPrintf(_T("DWORD")); break;
2155 case wxRegKey::Type_Multi_String
: wxPrintf(_T("MULTI_SZ")); break;
2156 default: wxPrintf(_T("other (unknown)")); break;
2159 wxPrintf(_T(", value = "));
2160 if ( key
.IsNumericValue(value
) )
2163 key
.QueryValue(value
, &val
);
2164 wxPrintf(_T("%ld"), val
);
2169 key
.QueryValue(value
, val
);
2170 wxPrintf(_T("'%s'"), val
.c_str());
2172 key
.QueryRawValue(value
, val
);
2173 wxPrintf(_T(" (raw value '%s')"), val
.c_str());
2178 cont
= key
.GetNextValue(value
, dummy
);
2182 static void TestRegistryAssociation()
2185 The second call to deleteself genertaes an error message, with a
2186 messagebox saying .flo is crucial to system operation, while the .ddf
2187 call also fails, but with no error message
2192 key
.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2194 key
= _T("ddxf_auto_file") ;
2195 key
.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2197 key
= _T("ddxf_auto_file") ;
2198 key
.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2200 key
= _T("program,0") ;
2201 key
.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2203 key
= _T("program \"%1\"") ;
2205 key
.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
2207 key
.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
2209 key
.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
2211 key
.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
2215 #endif // TEST_REGISTRY
2217 // ----------------------------------------------------------------------------
2219 // ----------------------------------------------------------------------------
2221 #ifdef TEST_SCOPEGUARD
2223 #include "wx/scopeguard.h"
2225 static void function0() { puts("function0()"); }
2226 static void function1(int n
) { printf("function1(%d)\n", n
); }
2227 static void function2(double x
, char c
) { printf("function2(%g, %c)\n", x
, c
); }
2231 void method0() { printf("method0()\n"); }
2232 void method1(int n
) { printf("method1(%d)\n", n
); }
2233 void method2(double x
, char c
) { printf("method2(%g, %c)\n", x
, c
); }
2236 static void TestScopeGuard()
2238 wxON_BLOCK_EXIT0(function0
);
2239 wxON_BLOCK_EXIT1(function1
, 17);
2240 wxON_BLOCK_EXIT2(function2
, 3.14, 'p');
2243 wxON_BLOCK_EXIT_OBJ0(obj
, Object::method0
);
2244 wxON_BLOCK_EXIT_OBJ1(obj
, Object::method1
, 7);
2245 wxON_BLOCK_EXIT_OBJ2(obj
, Object::method2
, 2.71, 'e');
2247 wxScopeGuard dismissed
= wxMakeGuard(function0
);
2248 dismissed
.Dismiss();
2253 // ----------------------------------------------------------------------------
2255 // ----------------------------------------------------------------------------
2259 #include "wx/socket.h"
2260 #include "wx/protocol/protocol.h"
2261 #include "wx/protocol/http.h"
2263 static void TestSocketServer()
2265 wxPuts(_T("*** Testing wxSocketServer ***\n"));
2267 static const int PORT
= 3000;
2272 wxSocketServer
*server
= new wxSocketServer(addr
);
2273 if ( !server
->Ok() )
2275 wxPuts(_T("ERROR: failed to bind"));
2283 wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT
);
2285 wxSocketBase
*socket
= server
->Accept();
2288 wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
2292 wxPuts(_T("Server: got a client."));
2294 server
->SetTimeout(60); // 1 min
2297 while ( !close
&& socket
->IsConnected() )
2300 wxChar ch
= _T('\0');
2303 if ( socket
->Read(&ch
, sizeof(ch
)).Error() )
2305 // don't log error if the client just close the connection
2306 if ( socket
->IsConnected() )
2308 wxPuts(_T("ERROR: in wxSocket::Read."));
2328 wxPrintf(_T("Server: got '%s'.\n"), s
.c_str());
2329 if ( s
== _T("close") )
2331 wxPuts(_T("Closing connection"));
2335 else if ( s
== _T("quit") )
2340 wxPuts(_T("Shutting down the server"));
2342 else // not a special command
2344 socket
->Write(s
.MakeUpper().c_str(), s
.length());
2345 socket
->Write("\r\n", 2);
2346 wxPrintf(_T("Server: wrote '%s'.\n"), s
.c_str());
2352 wxPuts(_T("Server: lost a client unexpectedly."));
2358 // same as "delete server" but is consistent with GUI programs
2362 static void TestSocketClient()
2364 wxPuts(_T("*** Testing wxSocketClient ***\n"));
2366 static const wxChar
*hostname
= _T("www.wxwidgets.org");
2369 addr
.Hostname(hostname
);
2372 wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname
);
2374 wxSocketClient client
;
2375 if ( !client
.Connect(addr
) )
2377 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname
);
2381 wxPrintf(_T("--- Connected to %s:%u...\n"),
2382 addr
.Hostname().c_str(), addr
.Service());
2386 // could use simply "GET" here I suppose
2388 wxString::Format(_T("GET http://%s/\r\n"), hostname
);
2389 client
.Write(cmdGet
, cmdGet
.length());
2390 wxPrintf(_T("--- Sent command '%s' to the server\n"),
2391 MakePrintable(cmdGet
).c_str());
2392 client
.Read(buf
, WXSIZEOF(buf
));
2393 wxPrintf(_T("--- Server replied:\n%s"), buf
);
2397 #endif // TEST_SOCKETS
2399 // ----------------------------------------------------------------------------
2401 // ----------------------------------------------------------------------------
2405 #include "wx/protocol/ftp.h"
2409 #define FTP_ANONYMOUS
2411 #ifdef FTP_ANONYMOUS
2412 static const wxChar
*directory
= _T("/pub");
2413 static const wxChar
*filename
= _T("welcome.msg");
2415 static const wxChar
*directory
= _T("/etc");
2416 static const wxChar
*filename
= _T("issue");
2419 static bool TestFtpConnect()
2421 wxPuts(_T("*** Testing FTP connect ***"));
2423 #ifdef FTP_ANONYMOUS
2424 static const wxChar
*hostname
= _T("ftp.wxwidgets.org");
2426 wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname
);
2427 #else // !FTP_ANONYMOUS
2428 static const wxChar
*hostname
= "localhost";
2431 wxFgets(user
, WXSIZEOF(user
), stdin
);
2432 user
[wxStrlen(user
) - 1] = '\0'; // chop off '\n'
2435 wxChar password
[256];
2436 wxPrintf(_T("Password for %s: "), password
);
2437 wxFgets(password
, WXSIZEOF(password
), stdin
);
2438 password
[wxStrlen(password
) - 1] = '\0'; // chop off '\n'
2439 ftp
.SetPassword(password
);
2441 wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname
, user
);
2442 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2444 if ( !ftp
.Connect(hostname
) )
2446 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname
);
2452 wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
2453 hostname
, ftp
.Pwd().c_str());
2460 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2461 static void TestFtpWuFtpd()
2464 static const wxChar
*hostname
= _T("ftp.eudora.com");
2465 if ( !ftp
.Connect(hostname
) )
2467 wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname
);
2471 static const wxChar
*filename
= _T("eudora/pubs/draft-gellens-submit-09.txt");
2472 wxInputStream
*in
= ftp
.GetInputStream(filename
);
2475 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename
);
2479 size_t size
= in
->GetSize();
2480 wxPrintf(_T("Reading file %s (%u bytes)..."), filename
, size
);
2482 wxChar
*data
= new wxChar
[size
];
2483 if ( !in
->Read(data
, size
) )
2485 wxPuts(_T("ERROR: read error"));
2489 wxPrintf(_T("Successfully retrieved the file.\n"));
2498 static void TestFtpList()
2500 wxPuts(_T("*** Testing wxFTP file listing ***\n"));
2503 if ( !ftp
.ChDir(directory
) )
2505 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory
);
2508 wxPrintf(_T("Current directory is '%s'\n"), ftp
.Pwd().c_str());
2510 // test NLIST and LIST
2511 wxArrayString files
;
2512 if ( !ftp
.GetFilesList(files
) )
2514 wxPuts(_T("ERROR: failed to get NLIST of files"));
2518 wxPrintf(_T("Brief list of files under '%s':\n"), ftp
.Pwd().c_str());
2519 size_t count
= files
.GetCount();
2520 for ( size_t n
= 0; n
< count
; n
++ )
2522 wxPrintf(_T("\t%s\n"), files
[n
].c_str());
2524 wxPuts(_T("End of the file list"));
2527 if ( !ftp
.GetDirList(files
) )
2529 wxPuts(_T("ERROR: failed to get LIST of files"));
2533 wxPrintf(_T("Detailed list of files under '%s':\n"), ftp
.Pwd().c_str());
2534 size_t count
= files
.GetCount();
2535 for ( size_t n
= 0; n
< count
; n
++ )
2537 wxPrintf(_T("\t%s\n"), files
[n
].c_str());
2539 wxPuts(_T("End of the file list"));
2542 if ( !ftp
.ChDir(_T("..")) )
2544 wxPuts(_T("ERROR: failed to cd to .."));
2547 wxPrintf(_T("Current directory is '%s'\n"), ftp
.Pwd().c_str());
2550 static void TestFtpDownload()
2552 wxPuts(_T("*** Testing wxFTP download ***\n"));
2555 wxInputStream
*in
= ftp
.GetInputStream(filename
);
2558 wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename
);
2562 size_t size
= in
->GetSize();
2563 wxPrintf(_T("Reading file %s (%u bytes)..."), filename
, size
);
2566 wxChar
*data
= new wxChar
[size
];
2567 if ( !in
->Read(data
, size
) )
2569 wxPuts(_T("ERROR: read error"));
2573 wxPrintf(_T("\nContents of %s:\n%s\n"), filename
, data
);
2581 static void TestFtpFileSize()
2583 wxPuts(_T("*** Testing FTP SIZE command ***"));
2585 if ( !ftp
.ChDir(directory
) )
2587 wxPrintf(_T("ERROR: failed to cd to %s\n"), directory
);
2590 wxPrintf(_T("Current directory is '%s'\n"), ftp
.Pwd().c_str());
2592 if ( ftp
.FileExists(filename
) )
2594 int size
= ftp
.GetFileSize(filename
);
2596 wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename
);
2598 wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename
, size
);
2602 wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename
);
2606 static void TestFtpMisc()
2608 wxPuts(_T("*** Testing miscellaneous wxFTP functions ***"));
2610 if ( ftp
.SendCommand(_T("STAT")) != '2' )
2612 wxPuts(_T("ERROR: STAT failed"));
2616 wxPrintf(_T("STAT returned:\n\n%s\n"), ftp
.GetLastResult().c_str());
2619 if ( ftp
.SendCommand(_T("HELP SITE")) != '2' )
2621 wxPuts(_T("ERROR: HELP SITE failed"));
2625 wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
2626 ftp
.GetLastResult().c_str());
2630 static void TestFtpInteractive()
2632 wxPuts(_T("\n*** Interactive wxFTP test ***"));
2638 wxPrintf(_T("Enter FTP command: "));
2639 if ( !wxFgets(buf
, WXSIZEOF(buf
), stdin
) )
2642 // kill the last '\n'
2643 buf
[wxStrlen(buf
) - 1] = 0;
2645 // special handling of LIST and NLST as they require data connection
2646 wxString
start(buf
, 4);
2648 if ( start
== _T("LIST") || start
== _T("NLST") )
2651 if ( wxStrlen(buf
) > 4 )
2654 wxArrayString files
;
2655 if ( !ftp
.GetList(files
, wildcard
, start
== _T("LIST")) )
2657 wxPrintf(_T("ERROR: failed to get %s of files\n"), start
.c_str());
2661 wxPrintf(_T("--- %s of '%s' under '%s':\n"),
2662 start
.c_str(), wildcard
.c_str(), ftp
.Pwd().c_str());
2663 size_t count
= files
.GetCount();
2664 for ( size_t n
= 0; n
< count
; n
++ )
2666 wxPrintf(_T("\t%s\n"), files
[n
].c_str());
2668 wxPuts(_T("--- End of the file list"));
2673 wxChar ch
= ftp
.SendCommand(buf
);
2674 wxPrintf(_T("Command %s"), ch
? _T("succeeded") : _T("failed"));
2677 wxPrintf(_T(" (return code %c)"), ch
);
2680 wxPrintf(_T(", server reply:\n%s\n\n"), ftp
.GetLastResult().c_str());
2684 wxPuts(_T("\n*** done ***"));
2687 static void TestFtpUpload()
2689 wxPuts(_T("*** Testing wxFTP uploading ***\n"));
2692 static const wxChar
*file1
= _T("test1");
2693 static const wxChar
*file2
= _T("test2");
2694 wxOutputStream
*out
= ftp
.GetOutputStream(file1
);
2697 wxPrintf(_T("--- Uploading to %s ---\n"), file1
);
2698 out
->Write("First hello", 11);
2702 // send a command to check the remote file
2703 if ( ftp
.SendCommand(wxString(_T("STAT ")) + file1
) != '2' )
2705 wxPrintf(_T("ERROR: STAT %s failed\n"), file1
);
2709 wxPrintf(_T("STAT %s returned:\n\n%s\n"),
2710 file1
, ftp
.GetLastResult().c_str());
2713 out
= ftp
.GetOutputStream(file2
);
2716 wxPrintf(_T("--- Uploading to %s ---\n"), file1
);
2717 out
->Write("Second hello", 12);
2724 // ----------------------------------------------------------------------------
2726 // ----------------------------------------------------------------------------
2728 #ifdef TEST_STACKWALKER
2730 #if wxUSE_STACKWALKER
2732 #include "wx/stackwalk.h"
2734 class StackDump
: public wxStackWalker
2737 StackDump(const char *argv0
)
2738 : wxStackWalker(argv0
)
2742 virtual void Walk(size_t skip
= 1)
2744 wxPuts(_T("Stack dump:"));
2746 wxStackWalker::Walk(skip
);
2750 virtual void OnStackFrame(const wxStackFrame
& frame
)
2752 printf("[%2d] ", (int) frame
.GetLevel());
2754 wxString name
= frame
.GetName();
2755 if ( !name
.empty() )
2757 printf("%-20.40s", (const char*)name
.mb_str());
2761 printf("0x%08lx", (unsigned long)frame
.GetAddress());
2764 if ( frame
.HasSourceLocation() )
2767 (const char*)frame
.GetFileName().mb_str(),
2768 (int)frame
.GetLine());
2774 for ( size_t n
= 0; frame
.GetParam(n
, &type
, &name
, &val
); n
++ )
2776 printf("\t%s %s = %s\n", (const char*)type
.mb_str(),
2777 (const char*)name
.mb_str(),
2778 (const char*)val
.mb_str());
2783 static void TestStackWalk(const char *argv0
)
2785 wxPuts(_T("*** Testing wxStackWalker ***\n"));
2787 StackDump
dump(argv0
);
2791 #endif // wxUSE_STACKWALKER
2793 #endif // TEST_STACKWALKER
2795 // ----------------------------------------------------------------------------
2797 // ----------------------------------------------------------------------------
2799 #ifdef TEST_STDPATHS
2801 #include "wx/stdpaths.h"
2802 #include "wx/wxchar.h" // wxPrintf
2804 static void TestStandardPaths()
2806 wxPuts(_T("*** Testing wxStandardPaths ***\n"));
2808 wxTheApp
->SetAppName(_T("console"));
2810 wxStandardPathsBase
& stdp
= wxStandardPaths::Get();
2811 wxPrintf(_T("Config dir (sys):\t%s\n"), stdp
.GetConfigDir().c_str());
2812 wxPrintf(_T("Config dir (user):\t%s\n"), stdp
.GetUserConfigDir().c_str());
2813 wxPrintf(_T("Data dir (sys):\t\t%s\n"), stdp
.GetDataDir().c_str());
2814 wxPrintf(_T("Data dir (sys local):\t%s\n"), stdp
.GetLocalDataDir().c_str());
2815 wxPrintf(_T("Data dir (user):\t%s\n"), stdp
.GetUserDataDir().c_str());
2816 wxPrintf(_T("Data dir (user local):\t%s\n"), stdp
.GetUserLocalDataDir().c_str());
2817 wxPrintf(_T("Documents dir:\t\t%s\n"), stdp
.GetDocumentsDir().c_str());
2818 wxPrintf(_T("Executable path:\t%s\n"), stdp
.GetExecutablePath().c_str());
2819 wxPrintf(_T("Plugins dir:\t\t%s\n"), stdp
.GetPluginsDir().c_str());
2820 wxPrintf(_T("Resources dir:\t\t%s\n"), stdp
.GetResourcesDir().c_str());
2821 wxPrintf(_T("Localized res. dir:\t%s\n"),
2822 stdp
.GetLocalizedResourcesDir(_T("fr")).c_str());
2823 wxPrintf(_T("Message catalogs dir:\t%s\n"),
2824 stdp
.GetLocalizedResourcesDir
2827 wxStandardPaths::ResourceCat_Messages
2831 #endif // TEST_STDPATHS
2833 // ----------------------------------------------------------------------------
2835 // ----------------------------------------------------------------------------
2839 #include "wx/wfstream.h"
2840 #include "wx/mstream.h"
2842 static void TestFileStream()
2844 wxPuts(_T("*** Testing wxFileInputStream ***"));
2846 static const wxString filename
= _T("testdata.fs");
2848 wxFileOutputStream
fsOut(filename
);
2849 fsOut
.Write("foo", 3);
2853 wxFileInputStream
fsIn(filename
);
2854 wxPrintf(_T("File stream size: %u\n"), fsIn
.GetSize());
2855 while ( !fsIn
.Eof() )
2857 wxPutchar(fsIn
.GetC());
2861 if ( !wxRemoveFile(filename
) )
2863 wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename
.c_str());
2866 wxPuts(_T("\n*** wxFileInputStream test done ***"));
2869 static void TestMemoryStream()
2871 wxPuts(_T("*** Testing wxMemoryOutputStream ***"));
2873 wxMemoryOutputStream memOutStream
;
2874 wxPrintf(_T("Initially out stream offset: %lu\n"),
2875 (unsigned long)memOutStream
.TellO());
2877 for ( const wxChar
*p
= _T("Hello, stream!"); *p
; p
++ )
2879 memOutStream
.PutC(*p
);
2882 wxPrintf(_T("Final out stream offset: %lu\n"),
2883 (unsigned long)memOutStream
.TellO());
2885 wxPuts(_T("*** Testing wxMemoryInputStream ***"));
2888 size_t len
= memOutStream
.CopyTo(buf
, WXSIZEOF(buf
));
2890 wxMemoryInputStream
memInpStream(buf
, len
);
2891 wxPrintf(_T("Memory stream size: %u\n"), memInpStream
.GetSize());
2892 while ( !memInpStream
.Eof() )
2894 wxPutchar(memInpStream
.GetC());
2897 wxPuts(_T("\n*** wxMemoryInputStream test done ***"));
2900 #endif // TEST_STREAMS
2902 // ----------------------------------------------------------------------------
2904 // ----------------------------------------------------------------------------
2908 #include "wx/stopwatch.h"
2909 #include "wx/utils.h"
2911 static void TestStopWatch()
2913 wxPuts(_T("*** Testing wxStopWatch ***\n"));
2917 wxPrintf(_T("Initially paused, after 2 seconds time is..."));
2920 wxPrintf(_T("\t%ldms\n"), sw
.Time());
2922 wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
2926 wxPrintf(_T("\telapsed time: %ldms\n"), sw
.Time());
2929 wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
2932 wxPrintf(_T("\telapsed time: %ldms\n"), sw
.Time());
2935 wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
2938 wxPrintf(_T("\telapsed time: %ldms\n"), sw
.Time());
2941 wxPuts(_T("\nChecking for 'backwards clock' bug..."));
2942 for ( size_t n
= 0; n
< 70; n
++ )
2946 for ( size_t m
= 0; m
< 100000; m
++ )
2948 if ( sw
.Time() < 0 || sw2
.Time() < 0 )
2950 wxPuts(_T("\ntime is negative - ERROR!"));
2958 wxPuts(_T(", ok."));
2961 #include "wx/timer.h"
2962 #include "wx/evtloop.h"
2966 wxPuts(_T("*** Testing wxTimer ***\n"));
2968 class MyTimer
: public wxTimer
2971 MyTimer() : wxTimer() { m_num
= 0; }
2973 virtual void Notify()
2975 wxPrintf(_T("%d"), m_num
++);
2980 wxPrintf(_T("... exiting the event loop"));
2983 wxEventLoop::GetActive()->Exit(0);
2984 wxPuts(_T(", ok."));
2997 timer1
.Start(100, true /* one shot */);
2999 timer1
.Start(100, true /* one shot */);
3007 #endif // TEST_TIMER
3009 // ----------------------------------------------------------------------------
3011 // ----------------------------------------------------------------------------
3015 #include "wx/vcard.h"
3017 static void DumpVObject(size_t level
, const wxVCardObject
& vcard
)
3020 wxVCardObject
*vcObj
= vcard
.GetFirstProp(&cookie
);
3023 wxPrintf(_T("%s%s"),
3024 wxString(_T('\t'), level
).c_str(),
3025 vcObj
->GetName().c_str());
3028 switch ( vcObj
->GetType() )
3030 case wxVCardObject::String
:
3031 case wxVCardObject::UString
:
3034 vcObj
->GetValue(&val
);
3035 value
<< _T('"') << val
<< _T('"');
3039 case wxVCardObject::Int
:
3042 vcObj
->GetValue(&i
);
3043 value
.Printf(_T("%u"), i
);
3047 case wxVCardObject::Long
:
3050 vcObj
->GetValue(&l
);
3051 value
.Printf(_T("%lu"), l
);
3055 case wxVCardObject::None
:
3058 case wxVCardObject::Object
:
3059 value
= _T("<node>");
3063 value
= _T("<unknown value type>");
3067 wxPrintf(_T(" = %s"), value
.c_str());
3070 DumpVObject(level
+ 1, *vcObj
);
3073 vcObj
= vcard
.GetNextProp(&cookie
);
3077 static void DumpVCardAddresses(const wxVCard
& vcard
)
3079 wxPuts(_T("\nShowing all addresses from vCard:\n"));
3083 wxVCardAddress
*addr
= vcard
.GetFirstAddress(&cookie
);
3087 int flags
= addr
->GetFlags();
3088 if ( flags
& wxVCardAddress::Domestic
)
3090 flagsStr
<< _T("domestic ");
3092 if ( flags
& wxVCardAddress::Intl
)
3094 flagsStr
<< _T("international ");
3096 if ( flags
& wxVCardAddress::Postal
)
3098 flagsStr
<< _T("postal ");
3100 if ( flags
& wxVCardAddress::Parcel
)
3102 flagsStr
<< _T("parcel ");
3104 if ( flags
& wxVCardAddress::Home
)
3106 flagsStr
<< _T("home ");
3108 if ( flags
& wxVCardAddress::Work
)
3110 flagsStr
<< _T("work ");
3113 wxPrintf(_T("Address %u:\n")
3115 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3118 addr
->GetPostOffice().c_str(),
3119 addr
->GetExtAddress().c_str(),
3120 addr
->GetStreet().c_str(),
3121 addr
->GetLocality().c_str(),
3122 addr
->GetRegion().c_str(),
3123 addr
->GetPostalCode().c_str(),
3124 addr
->GetCountry().c_str()
3128 addr
= vcard
.GetNextAddress(&cookie
);
3132 static void DumpVCardPhoneNumbers(const wxVCard
& vcard
)
3134 wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
3138 wxVCardPhoneNumber
*phone
= vcard
.GetFirstPhoneNumber(&cookie
);
3142 int flags
= phone
->GetFlags();
3143 if ( flags
& wxVCardPhoneNumber::Voice
)
3145 flagsStr
<< _T("voice ");
3147 if ( flags
& wxVCardPhoneNumber::Fax
)
3149 flagsStr
<< _T("fax ");
3151 if ( flags
& wxVCardPhoneNumber::Cellular
)
3153 flagsStr
<< _T("cellular ");
3155 if ( flags
& wxVCardPhoneNumber::Modem
)
3157 flagsStr
<< _T("modem ");
3159 if ( flags
& wxVCardPhoneNumber::Home
)
3161 flagsStr
<< _T("home ");
3163 if ( flags
& wxVCardPhoneNumber::Work
)
3165 flagsStr
<< _T("work ");
3168 wxPrintf(_T("Phone number %u:\n")
3173 phone
->GetNumber().c_str()
3177 phone
= vcard
.GetNextPhoneNumber(&cookie
);
3181 static void TestVCardRead()
3183 wxPuts(_T("*** Testing wxVCard reading ***\n"));
3185 wxVCard
vcard(_T("vcard.vcf"));
3186 if ( !vcard
.IsOk() )
3188 wxPuts(_T("ERROR: couldn't load vCard."));
3192 // read individual vCard properties
3193 wxVCardObject
*vcObj
= vcard
.GetProperty("FN");
3197 vcObj
->GetValue(&value
);
3202 value
= _T("<none>");
3205 wxPrintf(_T("Full name retrieved directly: %s\n"), value
.c_str());
3208 if ( !vcard
.GetFullName(&value
) )
3210 value
= _T("<none>");
3213 wxPrintf(_T("Full name from wxVCard API: %s\n"), value
.c_str());
3215 // now show how to deal with multiply occurring properties
3216 DumpVCardAddresses(vcard
);
3217 DumpVCardPhoneNumbers(vcard
);
3219 // and finally show all
3220 wxPuts(_T("\nNow dumping the entire vCard:\n")
3221 "-----------------------------\n");
3223 DumpVObject(0, vcard
);
3227 static void TestVCardWrite()
3229 wxPuts(_T("*** Testing wxVCard writing ***\n"));
3232 if ( !vcard
.IsOk() )
3234 wxPuts(_T("ERROR: couldn't create vCard."));
3239 vcard
.SetName("Zeitlin", "Vadim");
3240 vcard
.SetFullName("Vadim Zeitlin");
3241 vcard
.SetOrganization("wxWidgets", "R&D");
3243 // just dump the vCard back
3244 wxPuts(_T("Entire vCard follows:\n"));
3245 wxPuts(vcard
.Write());
3249 #endif // TEST_VCARD
3251 // ----------------------------------------------------------------------------
3253 // ----------------------------------------------------------------------------
3255 #if !defined(__WIN32__) || !wxUSE_FSVOLUME
3261 #include "wx/volume.h"
3263 static const wxChar
*volumeKinds
[] =
3269 _T("network volume"),
3273 static void TestFSVolume()
3275 wxPuts(_T("*** Testing wxFSVolume class ***"));
3277 wxArrayString volumes
= wxFSVolume::GetVolumes();
3278 size_t count
= volumes
.GetCount();
3282 wxPuts(_T("ERROR: no mounted volumes?"));
3286 wxPrintf(_T("%u mounted volumes found:\n"), count
);
3288 for ( size_t n
= 0; n
< count
; n
++ )
3290 wxFSVolume
vol(volumes
[n
]);
3293 wxPuts(_T("ERROR: couldn't create volume"));
3297 wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
3299 vol
.GetDisplayName().c_str(),
3300 vol
.GetName().c_str(),
3301 volumeKinds
[vol
.GetKind()],
3302 vol
.IsWritable() ? _T("rw") : _T("ro"),
3303 vol
.GetFlags() & wxFS_VOL_REMOVABLE
? _T("removable")
3308 #endif // TEST_VOLUME
3310 // ----------------------------------------------------------------------------
3311 // wide char and Unicode support
3312 // ----------------------------------------------------------------------------
3316 #include "wx/strconv.h"
3317 #include "wx/fontenc.h"
3318 #include "wx/encconv.h"
3319 #include "wx/buffer.h"
3321 static const unsigned char utf8koi8r
[] =
3323 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3324 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3325 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3326 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3327 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3328 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3329 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3332 static const unsigned char utf8iso8859_1
[] =
3334 0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
3335 0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
3336 0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
3337 0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
3338 0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
3341 static const unsigned char utf8Invalid
[] =
3343 0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
3344 0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
3345 0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
3346 0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
3350 static const struct Utf8Data
3352 const unsigned char *text
;
3354 const wxChar
*charset
;
3355 wxFontEncoding encoding
;
3358 { utf8Invalid
, WXSIZEOF(utf8Invalid
), _T("iso8859-1"), wxFONTENCODING_ISO8859_1
},
3359 { utf8koi8r
, WXSIZEOF(utf8koi8r
), _T("koi8-r"), wxFONTENCODING_KOI8
},
3360 { utf8iso8859_1
, WXSIZEOF(utf8iso8859_1
), _T("iso8859-1"), wxFONTENCODING_ISO8859_1
},
3363 static void TestUtf8()
3365 wxPuts(_T("*** Testing UTF8 support ***\n"));
3370 for ( size_t n
= 0; n
< WXSIZEOF(utf8data
); n
++ )
3372 const Utf8Data
& u8d
= utf8data
[n
];
3373 if ( wxConvUTF8
.MB2WC(wbuf
, (const char *)u8d
.text
,
3374 WXSIZEOF(wbuf
)) == (size_t)-1 )
3376 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3380 wxCSConv
conv(u8d
.charset
);
3381 if ( conv
.WC2MB(buf
, wbuf
, WXSIZEOF(buf
)) == (size_t)-1 )
3383 wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d
.charset
);
3387 wxPrintf(_T("String in %s: %s\n"), u8d
.charset
, buf
);
3391 wxString
s(wxConvUTF8
.cMB2WC((const char *)u8d
.text
));
3393 s
= _T("<< conversion failed >>");
3394 wxPrintf(_T("String in current cset: %s\n"), s
.c_str());
3398 wxPuts(wxEmptyString
);
3401 static void TestEncodingConverter()
3403 wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
3405 // using wxEncodingConverter should give the same result as above
3408 if ( wxConvUTF8
.MB2WC(wbuf
, (const char *)utf8koi8r
,
3409 WXSIZEOF(utf8koi8r
)) == (size_t)-1 )
3411 wxPuts(_T("ERROR: UTF-8 decoding failed."));
3415 wxEncodingConverter ec
;
3416 ec
.Init(wxFONTENCODING_UNICODE
, wxFONTENCODING_KOI8
);
3417 ec
.Convert(wbuf
, buf
);
3418 wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf
);
3421 wxPuts(wxEmptyString
);
3424 #endif // TEST_WCHAR
3426 // ----------------------------------------------------------------------------
3428 // ----------------------------------------------------------------------------
3432 #include "wx/filesys.h"
3433 #include "wx/fs_zip.h"
3434 #include "wx/zipstrm.h"
3436 static const wxChar
*TESTFILE_ZIP
= _T("testdata.zip");
3438 static void TestZipStreamRead()
3440 wxPuts(_T("*** Testing ZIP reading ***\n"));
3442 static const wxString filename
= _T("foo");
3443 wxFFileInputStream
in(TESTFILE_ZIP
);
3444 wxZipInputStream
istr(in
);
3445 wxZipEntry
entry(filename
);
3446 istr
.OpenEntry(entry
);
3448 wxPrintf(_T("Archive size: %u\n"), istr
.GetSize());
3450 wxPrintf(_T("Dumping the file '%s':\n"), filename
.c_str());
3451 while ( !istr
.Eof() )
3453 wxPutchar(istr
.GetC());
3457 wxPuts(_T("\n----- done ------"));
3460 static void DumpZipDirectory(wxFileSystem
& fs
,
3461 const wxString
& dir
,
3462 const wxString
& indent
)
3464 wxString prefix
= wxString::Format(_T("%s#zip:%s"),
3465 TESTFILE_ZIP
, dir
.c_str());
3466 wxString wildcard
= prefix
+ _T("/*");
3468 wxString dirname
= fs
.FindFirst(wildcard
, wxDIR
);
3469 while ( !dirname
.empty() )
3471 if ( !dirname
.StartsWith(prefix
+ _T('/'), &dirname
) )
3473 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3478 wxPrintf(_T("%s%s\n"), indent
.c_str(), dirname
.c_str());
3480 DumpZipDirectory(fs
, dirname
,
3481 indent
+ wxString(_T(' '), 4));
3483 dirname
= fs
.FindNext();
3486 wxString filename
= fs
.FindFirst(wildcard
, wxFILE
);
3487 while ( !filename
.empty() )
3489 if ( !filename
.StartsWith(prefix
, &filename
) )
3491 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3496 wxPrintf(_T("%s%s\n"), indent
.c_str(), filename
.c_str());
3498 filename
= fs
.FindNext();
3502 static void TestZipFileSystem()
3504 wxPuts(_T("*** Testing ZIP file system ***\n"));
3506 wxFileSystem::AddHandler(new wxZipFSHandler
);
3508 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP
);
3510 DumpZipDirectory(fs
, _T(""), wxString(_T(' '), 4));
3515 // ----------------------------------------------------------------------------
3517 // ----------------------------------------------------------------------------
3519 #ifdef TEST_DATETIME
3521 #include "wx/math.h"
3522 #include "wx/datetime.h"
3524 // this test miscellaneous static wxDateTime functions
3528 static void TestTimeStatic()
3530 wxPuts(_T("\n*** wxDateTime static methods test ***"));
3532 // some info about the current date
3533 int year
= wxDateTime::GetCurrentYear();
3534 wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
3536 wxDateTime::IsLeapYear(year
) ? "" : "not ",
3537 wxDateTime::GetNumberOfDays(year
));
3539 wxDateTime::Month month
= wxDateTime::GetCurrentMonth();
3540 wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
3541 wxDateTime::GetMonthName(month
, wxDateTime::Name_Abbr
).c_str(),
3542 wxDateTime::GetMonthName(month
).c_str(),
3543 wxDateTime::GetNumberOfDays(month
));
3546 // test time zones stuff
3547 static void TestTimeZones()
3549 wxPuts(_T("\n*** wxDateTime timezone test ***"));
3551 wxDateTime now
= wxDateTime::Now();
3553 wxPrintf(_T("Current GMT time:\t%s\n"), now
.Format(_T("%c"), wxDateTime::GMT0
).c_str());
3554 wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0
).c_str());
3555 wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST
).c_str());
3556 wxPrintf(_T("Current time in Paris:\t%s\n"), now
.Format(_T("%c"), wxDateTime::CET
).c_str());
3557 wxPrintf(_T(" Moscow:\t%s\n"), now
.Format(_T("%c"), wxDateTime::MSK
).c_str());
3558 wxPrintf(_T(" New York:\t%s\n"), now
.Format(_T("%c"), wxDateTime::EST
).c_str());
3560 wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
3562 wxDateTime::Tm tm
= now
.GetTm();
3563 if ( wxDateTime(tm
) != now
)
3565 wxPrintf(_T("ERROR: got %s instead of %s\n"),
3566 wxDateTime(tm
).Format().c_str(), now
.Format().c_str());
3570 // test some minimal support for the dates outside the standard range
3571 static void TestTimeRange()
3573 wxPuts(_T("\n*** wxDateTime out-of-standard-range dates test ***"));
3575 static const wxChar
*fmt
= _T("%d-%b-%Y %H:%M:%S");
3577 wxPrintf(_T("Unix epoch:\t%s\n"),
3578 wxDateTime(2440587.5).Format(fmt
).c_str());
3579 wxPrintf(_T("Feb 29, 0: \t%s\n"),
3580 wxDateTime(29, wxDateTime::Feb
, 0).Format(fmt
).c_str());
3581 wxPrintf(_T("JDN 0: \t%s\n"),
3582 wxDateTime(0.0).Format(fmt
).c_str());
3583 wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
3584 wxDateTime(1, wxDateTime::Jan
, 1).Format(fmt
).c_str());
3585 wxPrintf(_T("May 29, 2099:\t%s\n"),
3586 wxDateTime(29, wxDateTime::May
, 2099).Format(fmt
).c_str());
3589 // test DST calculations
3590 static void TestTimeDST()
3592 wxPuts(_T("\n*** wxDateTime DST test ***"));
3594 wxPrintf(_T("DST is%s in effect now.\n\n"),
3595 wxDateTime::Now().IsDST() ? wxEmptyString
: _T(" not"));
3597 for ( int year
= 1990; year
< 2005; year
++ )
3599 wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
3601 wxDateTime::GetBeginDST(year
, wxDateTime::Country_EEC
).Format().c_str(),
3602 wxDateTime::GetEndDST(year
, wxDateTime::Country_EEC
).Format().c_str());
3608 #if TEST_INTERACTIVE
3610 static void TestDateTimeInteractive()
3612 wxPuts(_T("\n*** interactive wxDateTime tests ***"));
3618 wxPrintf(_T("Enter a date: "));
3619 if ( !wxFgets(buf
, WXSIZEOF(buf
), stdin
) )
3622 // kill the last '\n'
3623 buf
[wxStrlen(buf
) - 1] = 0;
3626 const wxChar
*p
= dt
.ParseDate(buf
);
3629 wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf
);
3635 wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p
- buf
);
3638 wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
3639 dt
.Format(_T("%b %d, %Y")).c_str(),
3641 dt
.GetWeekOfMonth(wxDateTime::Monday_First
),
3642 dt
.GetWeekOfMonth(wxDateTime::Sunday_First
),
3643 dt
.GetWeekOfYear(wxDateTime::Monday_First
));
3646 wxPuts(_T("\n*** done ***"));
3649 #endif // TEST_INTERACTIVE
3653 static void TestTimeMS()
3655 wxPuts(_T("*** testing millisecond-resolution support in wxDateTime ***"));
3657 wxDateTime dt1
= wxDateTime::Now(),
3658 dt2
= wxDateTime::UNow();
3660 wxPrintf(_T("Now = %s\n"), dt1
.Format(_T("%H:%M:%S:%l")).c_str());
3661 wxPrintf(_T("UNow = %s\n"), dt2
.Format(_T("%H:%M:%S:%l")).c_str());
3662 wxPrintf(_T("Dummy loop: "));
3663 for ( int i
= 0; i
< 6000; i
++ )
3665 //for ( int j = 0; j < 10; j++ )
3668 s
.Printf(_T("%g"), sqrt((float)i
));
3674 wxPuts(_T(", done"));
3677 dt2
= wxDateTime::UNow();
3678 wxPrintf(_T("UNow = %s\n"), dt2
.Format(_T("%H:%M:%S:%l")).c_str());
3680 wxPrintf(_T("Loop executed in %s ms\n"), (dt2
- dt1
).Format(_T("%l")).c_str());
3682 wxPuts(_T("\n*** done ***"));
3685 static void TestTimeHolidays()
3687 wxPuts(_T("\n*** testing wxDateTimeHolidayAuthority ***\n"));
3689 wxDateTime::Tm tm
= wxDateTime(29, wxDateTime::May
, 2000).GetTm();
3690 wxDateTime
dtStart(1, tm
.mon
, tm
.year
),
3691 dtEnd
= dtStart
.GetLastMonthDay();
3693 wxDateTimeArray hol
;
3694 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart
, dtEnd
, hol
);
3696 const wxChar
*format
= _T("%d-%b-%Y (%a)");
3698 wxPrintf(_T("All holidays between %s and %s:\n"),
3699 dtStart
.Format(format
).c_str(), dtEnd
.Format(format
).c_str());
3701 size_t count
= hol
.GetCount();
3702 for ( size_t n
= 0; n
< count
; n
++ )
3704 wxPrintf(_T("\t%s\n"), hol
[n
].Format(format
).c_str());
3707 wxPuts(wxEmptyString
);
3710 static void TestTimeZoneBug()
3712 wxPuts(_T("\n*** testing for DST/timezone bug ***\n"));
3714 wxDateTime date
= wxDateTime(1, wxDateTime::Mar
, 2000);
3715 for ( int i
= 0; i
< 31; i
++ )
3717 wxPrintf(_T("Date %s: week day %s.\n"),
3718 date
.Format(_T("%d-%m-%Y")).c_str(),
3719 date
.GetWeekDayName(date
.GetWeekDay()).c_str());
3721 date
+= wxDateSpan::Day();
3724 wxPuts(wxEmptyString
);
3727 static void TestTimeSpanFormat()
3729 wxPuts(_T("\n*** wxTimeSpan tests ***"));
3731 static const wxChar
*formats
[] =
3733 _T("(default) %H:%M:%S"),
3734 _T("%E weeks and %D days"),
3735 _T("%l milliseconds"),
3736 _T("(with ms) %H:%M:%S:%l"),
3737 _T("100%% of minutes is %M"), // test "%%"
3738 _T("%D days and %H hours"),
3739 _T("or also %S seconds"),
3742 wxTimeSpan
ts1(1, 2, 3, 4),
3744 for ( size_t n
= 0; n
< WXSIZEOF(formats
); n
++ )
3746 wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
3747 ts1
.Format(formats
[n
]).c_str(),
3748 ts2
.Format(formats
[n
]).c_str());
3751 wxPuts(wxEmptyString
);
3756 #endif // TEST_DATETIME
3758 // ----------------------------------------------------------------------------
3759 // wxTextInput/OutputStream
3760 // ----------------------------------------------------------------------------
3762 #ifdef TEST_TEXTSTREAM
3764 #include "wx/txtstrm.h"
3765 #include "wx/wfstream.h"
3767 static void TestTextInputStream()
3769 wxPuts(_T("\n*** wxTextInputStream test ***"));
3771 wxString filename
= _T("testdata.fc");
3772 wxFileInputStream
fsIn(filename
);
3775 wxPuts(_T("ERROR: couldn't open file."));
3779 wxTextInputStream
tis(fsIn
);
3784 const wxString s
= tis
.ReadLine();
3786 // line could be non empty if the last line of the file isn't
3787 // terminated with EOL
3788 if ( fsIn
.Eof() && s
.empty() )
3791 wxPrintf(_T("Line %d: %s\n"), line
++, s
.c_str());
3796 #endif // TEST_TEXTSTREAM
3798 // ----------------------------------------------------------------------------
3800 // ----------------------------------------------------------------------------
3804 #include "wx/thread.h"
3806 static size_t gs_counter
= (size_t)-1;
3807 static wxCriticalSection gs_critsect
;
3808 static wxSemaphore gs_cond
;
3810 class MyJoinableThread
: public wxThread
3813 MyJoinableThread(size_t n
) : wxThread(wxTHREAD_JOINABLE
)
3814 { m_n
= n
; Create(); }
3816 // thread execution starts here
3817 virtual ExitCode
Entry();
3823 wxThread::ExitCode
MyJoinableThread::Entry()
3825 unsigned long res
= 1;
3826 for ( size_t n
= 1; n
< m_n
; n
++ )
3830 // it's a loooong calculation :-)
3834 return (ExitCode
)res
;
3837 class MyDetachedThread
: public wxThread
3840 MyDetachedThread(size_t n
, wxChar ch
)
3844 m_cancelled
= false;
3849 // thread execution starts here
3850 virtual ExitCode
Entry();
3853 virtual void OnExit();
3856 size_t m_n
; // number of characters to write
3857 wxChar m_ch
; // character to write
3859 bool m_cancelled
; // false if we exit normally
3862 wxThread::ExitCode
MyDetachedThread::Entry()
3865 wxCriticalSectionLocker
lock(gs_critsect
);
3866 if ( gs_counter
== (size_t)-1 )
3872 for ( size_t n
= 0; n
< m_n
; n
++ )
3874 if ( TestDestroy() )
3884 wxThread::Sleep(100);
3890 void MyDetachedThread::OnExit()
3892 wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
3894 wxCriticalSectionLocker
lock(gs_critsect
);
3895 if ( !--gs_counter
&& !m_cancelled
)
3899 static void TestDetachedThreads()
3901 wxPuts(_T("\n*** Testing detached threads ***"));
3903 static const size_t nThreads
= 3;
3904 MyDetachedThread
*threads
[nThreads
];
3906 for ( n
= 0; n
< nThreads
; n
++ )
3908 threads
[n
] = new MyDetachedThread(10, 'A' + n
);
3911 threads
[0]->SetPriority(WXTHREAD_MIN_PRIORITY
);
3912 threads
[1]->SetPriority(WXTHREAD_MAX_PRIORITY
);
3914 for ( n
= 0; n
< nThreads
; n
++ )
3919 // wait until all threads terminate
3922 wxPuts(wxEmptyString
);
3925 static void TestJoinableThreads()
3927 wxPuts(_T("\n*** Testing a joinable thread (a loooong calculation...) ***"));
3929 // calc 10! in the background
3930 MyJoinableThread
thread(10);
3933 wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
3934 (unsigned long)thread
.Wait());
3937 static void TestThreadSuspend()
3939 wxPuts(_T("\n*** Testing thread suspend/resume functions ***"));
3941 MyDetachedThread
*thread
= new MyDetachedThread(15, 'X');
3945 // this is for this demo only, in a real life program we'd use another
3946 // condition variable which would be signaled from wxThread::Entry() to
3947 // tell us that the thread really started running - but here just wait a
3948 // bit and hope that it will be enough (the problem is, of course, that
3949 // the thread might still not run when we call Pause() which will result
3951 wxThread::Sleep(300);
3953 for ( size_t n
= 0; n
< 3; n
++ )
3957 wxPuts(_T("\nThread suspended"));
3960 // don't sleep but resume immediately the first time
3961 wxThread::Sleep(300);
3963 wxPuts(_T("Going to resume the thread"));
3968 wxPuts(_T("Waiting until it terminates now"));
3970 // wait until the thread terminates
3973 wxPuts(wxEmptyString
);
3976 static void TestThreadDelete()
3978 // As above, using Sleep() is only for testing here - we must use some
3979 // synchronisation object instead to ensure that the thread is still
3980 // running when we delete it - deleting a detached thread which already
3981 // terminated will lead to a crash!
3983 wxPuts(_T("\n*** Testing thread delete function ***"));
3985 MyDetachedThread
*thread0
= new MyDetachedThread(30, 'W');
3989 wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
3991 MyDetachedThread
*thread1
= new MyDetachedThread(30, 'Y');
3995 wxThread::Sleep(300);
3999 wxPuts(_T("\nDeleted a running thread."));
4001 MyDetachedThread
*thread2
= new MyDetachedThread(30, 'Z');
4005 wxThread::Sleep(300);
4011 wxPuts(_T("\nDeleted a sleeping thread."));
4013 MyJoinableThread
thread3(20);
4018 wxPuts(_T("\nDeleted a joinable thread."));
4020 MyJoinableThread
thread4(2);
4023 wxThread::Sleep(300);
4027 wxPuts(_T("\nDeleted a joinable thread which already terminated."));
4029 wxPuts(wxEmptyString
);
4032 class MyWaitingThread
: public wxThread
4035 MyWaitingThread( wxMutex
*mutex
, wxCondition
*condition
)
4038 m_condition
= condition
;
4043 virtual ExitCode
Entry()
4045 wxPrintf(_T("Thread %lu has started running.\n"), GetId());
4050 wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
4054 m_condition
->Wait();
4057 wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
4065 wxCondition
*m_condition
;
4068 static void TestThreadConditions()
4071 wxCondition
condition(mutex
);
4073 // otherwise its difficult to understand which log messages pertain to
4075 //wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
4076 // condition.GetId(), gs_cond.GetId());
4078 // create and launch threads
4079 MyWaitingThread
*threads
[10];
4082 for ( n
= 0; n
< WXSIZEOF(threads
); n
++ )
4084 threads
[n
] = new MyWaitingThread( &mutex
, &condition
);
4087 for ( n
= 0; n
< WXSIZEOF(threads
); n
++ )
4092 // wait until all threads run
4093 wxPuts(_T("Main thread is waiting for the other threads to start"));
4096 size_t nRunning
= 0;
4097 while ( nRunning
< WXSIZEOF(threads
) )
4103 wxPrintf(_T("Main thread: %u already running\n"), nRunning
);
4107 wxPuts(_T("Main thread: all threads started up."));
4110 wxThread::Sleep(500);
4113 // now wake one of them up
4114 wxPrintf(_T("Main thread: about to signal the condition.\n"));
4119 wxThread::Sleep(200);
4121 // wake all the (remaining) threads up, so that they can exit
4122 wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
4124 condition
.Broadcast();
4126 // give them time to terminate (dirty!)
4127 wxThread::Sleep(500);
4130 #include "wx/utils.h"
4132 class MyExecThread
: public wxThread
4135 MyExecThread(const wxString
& command
) : wxThread(wxTHREAD_JOINABLE
),
4141 virtual ExitCode
Entry()
4143 return (ExitCode
)wxExecute(m_command
, wxEXEC_SYNC
);
4150 static void TestThreadExec()
4152 wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
4154 MyExecThread
thread(_T("true"));
4157 wxPrintf(_T("Main program exit code: %ld.\n"),
4158 wxExecute(_T("false"), wxEXEC_SYNC
));
4160 wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread
.Wait());
4164 #include "wx/datetime.h"
4166 class MySemaphoreThread
: public wxThread
4169 MySemaphoreThread(int i
, wxSemaphore
*sem
)
4170 : wxThread(wxTHREAD_JOINABLE
),
4177 virtual ExitCode
Entry()
4179 wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
4180 wxDateTime::Now().FormatTime().c_str(), m_i
, (long)GetId());
4184 wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
4185 wxDateTime::Now().FormatTime().c_str(), m_i
, (long)GetId());
4189 wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
4190 wxDateTime::Now().FormatTime().c_str(), m_i
, (long)GetId());
4202 WX_DEFINE_ARRAY_PTR(wxThread
*, ArrayThreads
);
4204 static void TestSemaphore()
4206 wxPuts(_T("*** Testing wxSemaphore class. ***"));
4208 static const int SEM_LIMIT
= 3;
4210 wxSemaphore
sem(SEM_LIMIT
, SEM_LIMIT
);
4211 ArrayThreads threads
;
4213 for ( int i
= 0; i
< 3*SEM_LIMIT
; i
++ )
4215 threads
.Add(new MySemaphoreThread(i
, &sem
));
4216 threads
.Last()->Run();
4219 for ( size_t n
= 0; n
< threads
.GetCount(); n
++ )
4226 #endif // TEST_THREADS
4228 // ----------------------------------------------------------------------------
4230 // ----------------------------------------------------------------------------
4232 #ifdef TEST_SNGLINST
4233 #include "wx/snglinst.h"
4234 #endif // TEST_SNGLINST
4236 int main(int argc
, char **argv
)
4239 wxChar
**wxArgv
= new wxChar
*[argc
+ 1];
4244 for (n
= 0; n
< argc
; n
++ )
4246 wxMB2WXbuf warg
= wxConvertMB2WX(argv
[n
]);
4247 wxArgv
[n
] = wxStrdup(warg
);
4252 #else // !wxUSE_UNICODE
4254 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
4256 wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE
, "program");
4258 wxInitializer initializer
;
4261 fprintf(stderr
, "Failed to initialize the wxWidgets library, aborting.");
4266 #ifdef TEST_SNGLINST
4267 wxSingleInstanceChecker checker
;
4268 if ( checker
.Create(_T(".wxconsole.lock")) )
4270 if ( checker
.IsAnotherRunning() )
4272 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
4277 // wait some time to give time to launch another instance
4278 wxPrintf(_T("Press \"Enter\" to continue..."));
4281 else // failed to create
4283 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
4285 #endif // TEST_SNGLINST
4288 TestCmdLineConvert();
4290 #if wxUSE_CMDLINE_PARSER
4291 static const wxCmdLineEntryDesc cmdLineDesc
[] =
4293 { wxCMD_LINE_SWITCH
, "h", "help", "show this help message",
4294 wxCMD_LINE_VAL_NONE
, wxCMD_LINE_OPTION_HELP
},
4295 { wxCMD_LINE_SWITCH
, "v", "verbose", "be verbose" },
4296 { wxCMD_LINE_SWITCH
, "q", "quiet", "be quiet" },
4298 { wxCMD_LINE_OPTION
, "o", "output", "output file" },
4299 { wxCMD_LINE_OPTION
, "i", "input", "input dir" },
4300 { wxCMD_LINE_OPTION
, "s", "size", "output block size",
4301 wxCMD_LINE_VAL_NUMBER
},
4302 { wxCMD_LINE_OPTION
, "d", "date", "output file date",
4303 wxCMD_LINE_VAL_DATE
},
4304 { wxCMD_LINE_OPTION
, "f", "double", "output double",
4305 wxCMD_LINE_VAL_DOUBLE
},
4307 { wxCMD_LINE_PARAM
, NULL
, NULL
, "input file",
4308 wxCMD_LINE_VAL_STRING
, wxCMD_LINE_PARAM_MULTIPLE
},
4313 wxCmdLineParser
parser(cmdLineDesc
, argc
, wxArgv
);
4315 parser
.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
4316 wxCMD_LINE_VAL_STRING
,
4317 wxCMD_LINE_OPTION_MANDATORY
| wxCMD_LINE_NEEDS_SEPARATOR
);
4319 switch ( parser
.Parse() )
4322 wxLogMessage(_T("Help was given, terminating."));
4326 ShowCmdLine(parser
);
4330 wxLogMessage(_T("Syntax error detected, aborting."));
4333 #endif // wxUSE_CMDLINE_PARSER
4335 #endif // TEST_CMDLINE
4347 TestDllListLoaded();
4348 #endif // TEST_DYNLIB
4352 #endif // TEST_ENVIRON
4356 #endif // TEST_EXECUTE
4358 #ifdef TEST_FILECONF
4360 #endif // TEST_FILECONF
4364 #endif // TEST_LOCALE
4367 wxPuts(_T("*** Testing wxLog ***"));
4370 for ( size_t n
= 0; n
< 8000; n
++ )
4372 s
<< (wxChar
)(_T('A') + (n
% 26));
4375 wxLogWarning(_T("The length of the string is %lu"),
4376 (unsigned long)s
.length());
4379 msg
.Printf(_T("A very very long message: '%s', the end!\n"), s
.c_str());
4381 // this one shouldn't be truncated
4384 // but this one will because log functions use fixed size buffer
4385 // (note that it doesn't need '\n' at the end neither - will be added
4387 wxLogMessage(_T("A very very long message 2: '%s', the end!"), s
.c_str());
4397 #ifdef TEST_FILENAME
4400 TestFileNameDirManip();
4401 TestFileNameComparison();
4402 TestFileNameOperations();
4403 #endif // TEST_FILENAME
4405 #ifdef TEST_FILETIME
4410 #endif // TEST_FILETIME
4413 wxLog::AddTraceMask(FTP_TRACE_MASK
);
4414 if ( TestFtpConnect() )
4424 #if TEST_INTERACTIVE
4425 TestFtpInteractive();
4428 //else: connecting to the FTP server failed
4436 //wxLog::AddTraceMask(_T("mime"));
4440 TestMimeAssociate();
4445 #ifdef TEST_INFO_FUNCTIONS
4450 #if TEST_INTERACTIVE
4453 #endif // TEST_INFO_FUNCTIONS
4455 #ifdef TEST_PATHLIST
4457 #endif // TEST_PATHLIST
4461 #endif // TEST_PRINTF
4468 #endif // TEST_REGCONF
4470 #if defined TEST_REGEX && TEST_INTERACTIVE
4471 TestRegExInteractive();
4472 #endif // defined TEST_REGEX && TEST_INTERACTIVE
4474 #ifdef TEST_REGISTRY
4476 TestRegistryAssociation();
4477 #endif // TEST_REGISTRY
4482 #endif // TEST_SOCKETS
4489 #endif // TEST_STREAMS
4491 #ifdef TEST_TEXTSTREAM
4492 TestTextInputStream();
4493 #endif // TEST_TEXTSTREAM
4496 int nCPUs
= wxThread::GetCPUCount();
4497 wxPrintf(_T("This system has %d CPUs\n"), nCPUs
);
4499 wxThread::SetConcurrency(nCPUs
);
4501 TestJoinableThreads();
4504 TestJoinableThreads();
4505 TestDetachedThreads();
4506 TestThreadSuspend();
4508 TestThreadConditions();
4512 #endif // TEST_THREADS
4517 #endif // TEST_TIMER
4519 #ifdef TEST_DATETIME
4526 TestTimeSpanFormat();
4532 #if TEST_INTERACTIVE
4533 TestDateTimeInteractive();
4535 #endif // TEST_DATETIME
4537 #ifdef TEST_SCOPEGUARD
4541 #ifdef TEST_STACKWALKER
4542 #if wxUSE_STACKWALKER
4543 TestStackWalk(argv
[0]);
4545 #endif // TEST_STACKWALKER
4547 #ifdef TEST_STDPATHS
4548 TestStandardPaths();
4552 wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
4554 #endif // TEST_USLEEP
4559 #endif // TEST_VCARD
4563 #endif // TEST_VOLUME
4567 TestEncodingConverter();
4568 #endif // TEST_WCHAR
4571 TestZipStreamRead();
4572 TestZipFileSystem();
4577 for ( int n
= 0; n
< argc
; n
++ )
4582 #endif // wxUSE_UNICODE