1 /////////////////////////////////////////////////////////////////////////////
2 // Name: samples/console/console.cpp
3 // Purpose: a sample console (as opposed to GUI) progam using wxWindows
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
23 #error "This sample can't be compiled in GUI mode."
28 #include "wx/string.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 wxWindows classes and as a
45 scratchpad for quick tests. So there are two compilation modes: if you
46 define TEST_ALL all tests are run, otherwise you may enable the individual
47 tests individually in the "#else" branch below.
50 // what to test (in alphabetic order)? uncomment the line below to do all tests
58 #define TEST_DLLLOADER
68 #define TEST_INFO_FUNCTIONS
85 // #define TEST_VCARD -- don't enable this (VZ)
91 static const bool TEST_ALL
= TRUE
;
95 static const bool TEST_ALL
= FALSE
;
98 // some tests are interactive, define this to run them
99 #ifdef TEST_INTERACTIVE
100 #undef TEST_INTERACTIVE
102 static const bool TEST_INTERACTIVE
= FALSE
;
104 static const bool TEST_INTERACTIVE
= FALSE
;
107 // ----------------------------------------------------------------------------
108 // test class for container objects
109 // ----------------------------------------------------------------------------
111 #if defined(TEST_ARRAYS) || defined(TEST_LIST)
113 class Bar
// Foo is already taken in the hash test
116 Bar(const wxString
& name
) : m_name(name
) { ms_bars
++; }
117 ~Bar() { ms_bars
--; }
119 static size_t GetNumber() { return ms_bars
; }
121 const char *GetName() const { return m_name
; }
126 static size_t ms_bars
;
129 size_t Bar::ms_bars
= 0;
131 #endif // defined(TEST_ARRAYS) || defined(TEST_LIST)
133 // ============================================================================
135 // ============================================================================
137 // ----------------------------------------------------------------------------
139 // ----------------------------------------------------------------------------
141 #if defined(TEST_STRINGS) || defined(TEST_SOCKETS)
143 // replace TABs with \t and CRs with \n
144 static wxString
MakePrintable(const wxChar
*s
)
147 (void)str
.Replace(_T("\t"), _T("\\t"));
148 (void)str
.Replace(_T("\n"), _T("\\n"));
149 (void)str
.Replace(_T("\r"), _T("\\r"));
154 #endif // MakePrintable() is used
156 // ----------------------------------------------------------------------------
157 // wxFontMapper::CharsetToEncoding
158 // ----------------------------------------------------------------------------
162 #include "wx/fontmap.h"
164 static void TestCharset()
166 static const wxChar
*charsets
[] =
168 // some vali charsets
177 // and now some bogus ones
184 for ( size_t n
= 0; n
< WXSIZEOF(charsets
); n
++ )
186 wxFontEncoding enc
= wxTheFontMapper
->CharsetToEncoding(charsets
[n
]);
187 wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
189 wxTheFontMapper
->GetEncodingName(enc
).c_str(),
190 wxTheFontMapper
->GetEncodingDescription(enc
).c_str());
194 #endif // TEST_CHARSET
196 // ----------------------------------------------------------------------------
198 // ----------------------------------------------------------------------------
202 #include "wx/cmdline.h"
203 #include "wx/datetime.h"
205 #if wxUSE_CMDLINE_PARSER
207 static void ShowCmdLine(const wxCmdLineParser
& parser
)
209 wxString s
= "Input files: ";
211 size_t count
= parser
.GetParamCount();
212 for ( size_t param
= 0; param
< count
; param
++ )
214 s
<< parser
.GetParam(param
) << ' ';
218 << "Verbose:\t" << (parser
.Found("v") ? "yes" : "no") << '\n'
219 << "Quiet:\t" << (parser
.Found("q") ? "yes" : "no") << '\n';
224 if ( parser
.Found("o", &strVal
) )
225 s
<< "Output file:\t" << strVal
<< '\n';
226 if ( parser
.Found("i", &strVal
) )
227 s
<< "Input dir:\t" << strVal
<< '\n';
228 if ( parser
.Found("s", &lVal
) )
229 s
<< "Size:\t" << lVal
<< '\n';
230 if ( parser
.Found("d", &dt
) )
231 s
<< "Date:\t" << dt
.FormatISODate() << '\n';
232 if ( parser
.Found("project_name", &strVal
) )
233 s
<< "Project:\t" << strVal
<< '\n';
238 #endif // wxUSE_CMDLINE_PARSER
240 static void TestCmdLineConvert()
242 static const char *cmdlines
[] =
245 "-a \"-bstring 1\" -c\"string 2\" \"string 3\"",
246 "literal \\\" and \"\"",
249 for ( size_t n
= 0; n
< WXSIZEOF(cmdlines
); n
++ )
251 const char *cmdline
= cmdlines
[n
];
252 printf("Parsing: %s\n", cmdline
);
253 wxArrayString args
= wxCmdLineParser::ConvertStringToArgs(cmdline
);
255 size_t count
= args
.GetCount();
256 printf("\targc = %u\n", count
);
257 for ( size_t arg
= 0; arg
< count
; arg
++ )
259 printf("\targv[%u] = %s\n", arg
, args
[arg
].c_str());
264 #endif // TEST_CMDLINE
266 // ----------------------------------------------------------------------------
268 // ----------------------------------------------------------------------------
275 static const wxChar
*ROOTDIR
= _T("/");
276 static const wxChar
*TESTDIR
= _T("/usr");
277 #elif defined(__WXMSW__)
278 static const wxChar
*ROOTDIR
= _T("c:\\");
279 static const wxChar
*TESTDIR
= _T("d:\\");
281 #error "don't know where the root directory is"
284 static void TestDirEnumHelper(wxDir
& dir
,
285 int flags
= wxDIR_DEFAULT
,
286 const wxString
& filespec
= wxEmptyString
)
290 if ( !dir
.IsOpened() )
293 bool cont
= dir
.GetFirst(&filename
, filespec
, flags
);
296 printf("\t%s\n", filename
.c_str());
298 cont
= dir
.GetNext(&filename
);
304 static void TestDirEnum()
306 puts("*** Testing wxDir::GetFirst/GetNext ***");
308 wxDir
dir(wxGetCwd());
310 puts("Enumerating everything in current directory:");
311 TestDirEnumHelper(dir
);
313 puts("Enumerating really everything in current directory:");
314 TestDirEnumHelper(dir
, wxDIR_DEFAULT
| wxDIR_DOTDOT
);
316 puts("Enumerating object files in current directory:");
317 TestDirEnumHelper(dir
, wxDIR_DEFAULT
, "*.o");
319 puts("Enumerating directories in current directory:");
320 TestDirEnumHelper(dir
, wxDIR_DIRS
);
322 puts("Enumerating files in current directory:");
323 TestDirEnumHelper(dir
, wxDIR_FILES
);
325 puts("Enumerating files including hidden in current directory:");
326 TestDirEnumHelper(dir
, wxDIR_FILES
| wxDIR_HIDDEN
);
330 puts("Enumerating everything in root directory:");
331 TestDirEnumHelper(dir
, wxDIR_DEFAULT
);
333 puts("Enumerating directories in root directory:");
334 TestDirEnumHelper(dir
, wxDIR_DIRS
);
336 puts("Enumerating files in root directory:");
337 TestDirEnumHelper(dir
, wxDIR_FILES
);
339 puts("Enumerating files including hidden in root directory:");
340 TestDirEnumHelper(dir
, wxDIR_FILES
| wxDIR_HIDDEN
);
342 puts("Enumerating files in non existing directory:");
343 wxDir
dirNo("nosuchdir");
344 TestDirEnumHelper(dirNo
);
347 class DirPrintTraverser
: public wxDirTraverser
350 virtual wxDirTraverseResult
OnFile(const wxString
& filename
)
352 return wxDIR_CONTINUE
;
355 virtual wxDirTraverseResult
OnDir(const wxString
& dirname
)
357 wxString path
, name
, ext
;
358 wxSplitPath(dirname
, &path
, &name
, &ext
);
361 name
<< _T('.') << ext
;
364 for ( const wxChar
*p
= path
.c_str(); *p
; p
++ )
366 if ( wxIsPathSeparator(*p
) )
370 printf("%s%s\n", indent
.c_str(), name
.c_str());
372 return wxDIR_CONTINUE
;
376 static void TestDirTraverse()
378 puts("*** Testing wxDir::Traverse() ***");
382 size_t n
= wxDir::GetAllFiles(TESTDIR
, &files
);
383 printf("There are %u files under '%s'\n", n
, TESTDIR
);
386 printf("First one is '%s'\n", files
[0u].c_str());
387 printf(" last one is '%s'\n", files
[n
- 1].c_str());
390 // enum again with custom traverser
392 DirPrintTraverser traverser
;
393 dir
.Traverse(traverser
, _T(""), wxDIR_DIRS
| wxDIR_HIDDEN
);
398 // ----------------------------------------------------------------------------
400 // ----------------------------------------------------------------------------
402 #ifdef TEST_DLLLOADER
404 #include "wx/dynlib.h"
406 static void TestDllLoad()
408 #if defined(__WXMSW__)
409 static const wxChar
*LIB_NAME
= _T("kernel32.dll");
410 static const wxChar
*FUNC_NAME
= _T("lstrlenA");
411 #elif defined(__UNIX__)
412 // weird: using just libc.so does *not* work!
413 static const wxChar
*LIB_NAME
= _T("/lib/libc-2.0.7.so");
414 static const wxChar
*FUNC_NAME
= _T("strlen");
416 #error "don't know how to test wxDllLoader on this platform"
419 puts("*** testing wxDllLoader ***\n");
421 wxDllType dllHandle
= wxDllLoader::LoadLibrary(LIB_NAME
);
424 wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME
);
428 typedef int (*strlenType
)(const char *);
429 strlenType pfnStrlen
= (strlenType
)wxDllLoader::GetSymbol(dllHandle
, FUNC_NAME
);
432 wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
433 FUNC_NAME
, LIB_NAME
);
437 if ( pfnStrlen("foo") != 3 )
439 wxPrintf(_T("ERROR: loaded function is not strlen()!\n"));
447 wxDllLoader::UnloadLibrary(dllHandle
);
451 #endif // TEST_DLLLOADER
453 // ----------------------------------------------------------------------------
455 // ----------------------------------------------------------------------------
459 #include "wx/utils.h"
461 static wxString
MyGetEnv(const wxString
& var
)
464 if ( !wxGetEnv(var
, &val
) )
467 val
= wxString(_T('\'')) + val
+ _T('\'');
472 static void TestEnvironment()
474 const wxChar
*var
= _T("wxTestVar");
476 puts("*** testing environment access functions ***");
478 printf("Initially getenv(%s) = %s\n", var
, MyGetEnv(var
).c_str());
479 wxSetEnv(var
, _T("value for wxTestVar"));
480 printf("After wxSetEnv: getenv(%s) = %s\n", var
, MyGetEnv(var
).c_str());
481 wxSetEnv(var
, _T("another value"));
482 printf("After 2nd wxSetEnv: getenv(%s) = %s\n", var
, MyGetEnv(var
).c_str());
484 printf("After wxUnsetEnv: getenv(%s) = %s\n", var
, MyGetEnv(var
).c_str());
485 printf("PATH = %s\n", MyGetEnv(_T("PATH")).c_str());
488 #endif // TEST_ENVIRON
490 // ----------------------------------------------------------------------------
492 // ----------------------------------------------------------------------------
496 #include "wx/utils.h"
498 static void TestExecute()
500 puts("*** testing wxExecute ***");
503 #define COMMAND "cat -n ../../Makefile" // "echo hi"
504 #define SHELL_COMMAND "echo hi from shell"
505 #define REDIRECT_COMMAND COMMAND // "date"
506 #elif defined(__WXMSW__)
507 #define COMMAND "command.com -c 'echo hi'"
508 #define SHELL_COMMAND "echo hi"
509 #define REDIRECT_COMMAND COMMAND
511 #error "no command to exec"
514 printf("Testing wxShell: ");
516 if ( wxShell(SHELL_COMMAND
) )
521 printf("Testing wxExecute: ");
523 if ( wxExecute(COMMAND
, TRUE
/* sync */) == 0 )
528 #if 0 // no, it doesn't work (yet?)
529 printf("Testing async wxExecute: ");
531 if ( wxExecute(COMMAND
) != 0 )
532 puts("Ok (command launched).");
537 printf("Testing wxExecute with redirection:\n");
538 wxArrayString output
;
539 if ( wxExecute(REDIRECT_COMMAND
, output
) != 0 )
545 size_t count
= output
.GetCount();
546 for ( size_t n
= 0; n
< count
; n
++ )
548 printf("\t%s\n", output
[n
].c_str());
555 #endif // TEST_EXECUTE
557 // ----------------------------------------------------------------------------
559 // ----------------------------------------------------------------------------
564 #include "wx/ffile.h"
565 #include "wx/textfile.h"
567 static void TestFileRead()
569 puts("*** wxFile read test ***");
571 wxFile
file(_T("testdata.fc"));
572 if ( file
.IsOpened() )
574 printf("File length: %lu\n", file
.Length());
576 puts("File dump:\n----------");
578 static const off_t len
= 1024;
582 off_t nRead
= file
.Read(buf
, len
);
583 if ( nRead
== wxInvalidOffset
)
585 printf("Failed to read the file.");
589 fwrite(buf
, nRead
, 1, stdout
);
599 printf("ERROR: can't open test file.\n");
605 static void TestTextFileRead()
607 puts("*** wxTextFile read test ***");
609 wxTextFile
file(_T("testdata.fc"));
612 printf("Number of lines: %u\n", file
.GetLineCount());
613 printf("Last line: '%s'\n", file
.GetLastLine().c_str());
617 puts("\nDumping the entire file:");
618 for ( s
= file
.GetFirstLine(); !file
.Eof(); s
= file
.GetNextLine() )
620 printf("%6u: %s\n", file
.GetCurrentLine() + 1, s
.c_str());
622 printf("%6u: %s\n", file
.GetCurrentLine() + 1, s
.c_str());
624 puts("\nAnd now backwards:");
625 for ( s
= file
.GetLastLine();
626 file
.GetCurrentLine() != 0;
627 s
= file
.GetPrevLine() )
629 printf("%6u: %s\n", file
.GetCurrentLine() + 1, s
.c_str());
631 printf("%6u: %s\n", file
.GetCurrentLine() + 1, s
.c_str());
635 printf("ERROR: can't open '%s'\n", file
.GetName());
641 static void TestFileCopy()
643 puts("*** Testing wxCopyFile ***");
645 static const wxChar
*filename1
= _T("testdata.fc");
646 static const wxChar
*filename2
= _T("test2");
647 if ( !wxCopyFile(filename1
, filename2
) )
649 puts("ERROR: failed to copy file");
653 wxFFile
f1(filename1
, "rb"),
656 if ( !f1
.IsOpened() || !f2
.IsOpened() )
658 puts("ERROR: failed to open file(s)");
663 if ( !f1
.ReadAll(&s1
) || !f2
.ReadAll(&s2
) )
665 puts("ERROR: failed to read file(s)");
669 if ( (s1
.length() != s2
.length()) ||
670 (memcmp(s1
.c_str(), s2
.c_str(), s1
.length()) != 0) )
672 puts("ERROR: copy error!");
676 puts("File was copied ok.");
682 if ( !wxRemoveFile(filename2
) )
684 puts("ERROR: failed to remove the file");
692 // ----------------------------------------------------------------------------
694 // ----------------------------------------------------------------------------
698 #include "wx/confbase.h"
699 #include "wx/fileconf.h"
701 static const struct FileConfTestData
703 const wxChar
*name
; // value name
704 const wxChar
*value
; // the value from the file
707 { _T("value1"), _T("one") },
708 { _T("value2"), _T("two") },
709 { _T("novalue"), _T("default") },
712 static void TestFileConfRead()
714 puts("*** testing wxFileConfig loading/reading ***");
716 wxFileConfig
fileconf(_T("test"), wxEmptyString
,
717 _T("testdata.fc"), wxEmptyString
,
718 wxCONFIG_USE_RELATIVE_PATH
);
720 // test simple reading
721 puts("\nReading config file:");
722 wxString
defValue(_T("default")), value
;
723 for ( size_t n
= 0; n
< WXSIZEOF(fcTestData
); n
++ )
725 const FileConfTestData
& data
= fcTestData
[n
];
726 value
= fileconf
.Read(data
.name
, defValue
);
727 printf("\t%s = %s ", data
.name
, value
.c_str());
728 if ( value
== data
.value
)
734 printf("(ERROR: should be %s)\n", data
.value
);
738 // test enumerating the entries
739 puts("\nEnumerating all root entries:");
742 bool cont
= fileconf
.GetFirstEntry(name
, dummy
);
745 printf("\t%s = %s\n",
747 fileconf
.Read(name
.c_str(), _T("ERROR")).c_str());
749 cont
= fileconf
.GetNextEntry(name
, dummy
);
753 #endif // TEST_FILECONF
755 // ----------------------------------------------------------------------------
757 // ----------------------------------------------------------------------------
761 #include "wx/filename.h"
763 static void DumpFileName(const wxFileName
& fn
)
765 wxString full
= fn
.GetFullPath();
767 wxString vol
, path
, name
, ext
;
768 wxFileName::SplitPath(full
, &vol
, &path
, &name
, &ext
);
770 wxPrintf(_T("Filename '%s' -> vol '%s', path '%s', name '%s', ext '%s'\n"),
771 full
.c_str(), vol
.c_str(), path
.c_str(), name
.c_str(), ext
.c_str());
774 static struct FileNameInfo
776 const wxChar
*fullname
;
777 const wxChar
*volume
;
786 { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), TRUE
, wxPATH_UNIX
},
787 { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), TRUE
, wxPATH_UNIX
},
788 { _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), TRUE
, wxPATH_UNIX
},
789 { _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), FALSE
, wxPATH_UNIX
},
790 { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE
, wxPATH_UNIX
},
791 { _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), TRUE
, wxPATH_UNIX
},
792 { _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), TRUE
, wxPATH_UNIX
},
793 { _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), FALSE
, wxPATH_UNIX
},
794 { _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), TRUE
, wxPATH_UNIX
},
796 // Windows file names
797 { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE
, wxPATH_DOS
},
798 { _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), FALSE
, wxPATH_DOS
},
799 { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), FALSE
, wxPATH_DOS
},
800 { _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), TRUE
, wxPATH_DOS
},
801 { _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), TRUE
, wxPATH_DOS
},
802 { _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), TRUE
, wxPATH_DOS
},
805 { _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), TRUE
, wxPATH_MAC
},
806 { _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), TRUE
, wxPATH_MAC
},
807 { _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), TRUE
, wxPATH_MAC
},
808 { _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), FALSE
, wxPATH_MAC
},
809 { _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE
, wxPATH_MAC
},
810 { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE
, wxPATH_MAC
},
813 { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE
, wxPATH_VMS
},
814 { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), FALSE
, wxPATH_VMS
},
817 static void TestFileNameConstruction()
819 puts("*** testing wxFileName construction ***");
821 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
823 const FileNameInfo
& fni
= filenames
[n
];
825 wxFileName
fn(fni
.fullname
, fni
.format
);
827 wxString fullname
= fn
.GetFullPath(fni
.format
);
828 if ( fullname
!= fni
.fullname
)
830 printf("ERROR: fullname should be '%s'\n", fni
.fullname
);
833 bool isAbsolute
= fn
.IsAbsolute();
834 printf("'%s' is %s (%s)\n\t",
836 isAbsolute
? "absolute" : "relative",
837 isAbsolute
== fni
.isAbsolute
? "ok" : "ERROR");
839 if ( !fn
.Normalize(wxPATH_NORM_ALL
, _T(""), fni
.format
) )
841 puts("ERROR (couldn't be normalized)");
845 printf("normalized: '%s'\n", fn
.GetFullPath(fni
.format
).c_str());
852 static void TestFileNameSplit()
854 puts("*** testing wxFileName splitting ***");
856 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
858 const FileNameInfo
& fni
= filenames
[n
];
859 wxString volume
, path
, name
, ext
;
860 wxFileName::SplitPath(fni
.fullname
,
861 &volume
, &path
, &name
, &ext
, fni
.format
);
863 printf("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'",
865 volume
.c_str(), path
.c_str(), name
.c_str(), ext
.c_str());
867 if ( volume
!= fni
.volume
)
868 printf(" (ERROR: volume = '%s')", fni
.volume
);
869 if ( path
!= fni
.path
)
870 printf(" (ERROR: path = '%s')", fni
.path
);
871 if ( name
!= fni
.name
)
872 printf(" (ERROR: name = '%s')", fni
.name
);
873 if ( ext
!= fni
.ext
)
874 printf(" (ERROR: ext = '%s')", fni
.ext
);
880 static void TestFileNameTemp()
882 puts("*** testing wxFileName temp file creation ***");
884 static const char *tmpprefixes
[] =
890 "/tmp/foo/bar", // this one must be an error
893 for ( size_t n
= 0; n
< WXSIZEOF(tmpprefixes
); n
++ )
895 wxString path
= wxFileName::CreateTempFileName(tmpprefixes
[n
]);
898 printf("Prefix '%s'\t-> temp file '%s'\n",
899 tmpprefixes
[n
], path
.c_str());
901 if ( !wxRemoveFile(path
) )
903 wxLogWarning("Failed to remove temp file '%s'", path
.c_str());
909 static void TestFileNameMakeRelative()
911 puts("*** testing wxFileName::MakeRelativeTo() ***");
913 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
915 const FileNameInfo
& fni
= filenames
[n
];
917 wxFileName
fn(fni
.fullname
, fni
.format
);
919 // choose the base dir of the same format
921 switch ( fni
.format
)
933 // TODO: I don't know how this is supposed to work there
936 case wxPATH_NATIVE
: // make gcc happy
938 wxFAIL_MSG( "unexpected path format" );
941 printf("'%s' relative to '%s': ",
942 fn
.GetFullPath(fni
.format
).c_str(), base
.c_str());
944 if ( !fn
.MakeRelativeTo(base
, fni
.format
) )
950 printf("'%s'\n", fn
.GetFullPath(fni
.format
).c_str());
955 static void TestFileNameComparison()
960 static void TestFileNameOperations()
965 static void TestFileNameCwd()
970 #endif // TEST_FILENAME
972 // ----------------------------------------------------------------------------
973 // wxFileName time functions
974 // ----------------------------------------------------------------------------
978 #include <wx/filename.h>
979 #include <wx/datetime.h>
981 static void TestFileGetTimes()
983 wxFileName
fn(_T("testdata.fc"));
985 wxDateTime dtAccess
, dtMod
, dtChange
;
986 if ( !fn
.GetTimes(&dtAccess
, &dtMod
, &dtChange
) )
988 wxPrintf(_T("ERROR: GetTimes() failed.\n"));
992 static const wxChar
*fmt
= _T("%Y-%b-%d %H:%M:%S");
994 wxPrintf(_T("File times for '%s':\n"), fn
.GetFullPath().c_str());
995 wxPrintf(_T("Access: \t%s\n"), dtAccess
.Format(fmt
).c_str());
996 wxPrintf(_T("Mod/creation:\t%s\n"), dtMod
.Format(fmt
).c_str());
997 wxPrintf(_T("Change: \t%s\n"), dtChange
.Format(fmt
).c_str());
1001 static void TestFileSetTimes()
1003 wxFileName
fn(_T("testdata.fc"));
1007 wxPrintf(_T("ERROR: Touch() failed.\n"));
1011 #endif // TEST_FILETIME
1013 // ----------------------------------------------------------------------------
1015 // ----------------------------------------------------------------------------
1019 #include "wx/hash.h"
1023 Foo(int n_
) { n
= n_
; count
++; }
1028 static size_t count
;
1031 size_t Foo::count
= 0;
1033 WX_DECLARE_LIST(Foo
, wxListFoos
);
1034 WX_DECLARE_HASH(Foo
, wxListFoos
, wxHashFoos
);
1036 #include "wx/listimpl.cpp"
1038 WX_DEFINE_LIST(wxListFoos
);
1040 static void TestHash()
1042 puts("*** Testing wxHashTable ***\n");
1046 hash
.DeleteContents(TRUE
);
1048 printf("Hash created: %u foos in hash, %u foos totally\n",
1049 hash
.GetCount(), Foo::count
);
1051 static const int hashTestData
[] =
1053 0, 1, 17, -2, 2, 4, -4, 345, 3, 3, 2, 1,
1057 for ( n
= 0; n
< WXSIZEOF(hashTestData
); n
++ )
1059 hash
.Put(hashTestData
[n
], n
, new Foo(n
));
1062 printf("Hash filled: %u foos in hash, %u foos totally\n",
1063 hash
.GetCount(), Foo::count
);
1065 puts("Hash access test:");
1066 for ( n
= 0; n
< WXSIZEOF(hashTestData
); n
++ )
1068 printf("\tGetting element with key %d, value %d: ",
1069 hashTestData
[n
], n
);
1070 Foo
*foo
= hash
.Get(hashTestData
[n
], n
);
1073 printf("ERROR, not found.\n");
1077 printf("%d (%s)\n", foo
->n
,
1078 (size_t)foo
->n
== n
? "ok" : "ERROR");
1082 printf("\nTrying to get an element not in hash: ");
1084 if ( hash
.Get(1234) || hash
.Get(1, 0) )
1086 puts("ERROR: found!");
1090 puts("ok (not found)");
1094 printf("Hash destroyed: %u foos left\n", Foo::count
);
1099 // ----------------------------------------------------------------------------
1101 // ----------------------------------------------------------------------------
1105 #include "wx/hashmap.h"
1107 // test compilation of basic map types
1108 WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash
, wxPointerEqual
, myPtrHashMap
);
1109 WX_DECLARE_HASH_MAP( long, long, wxIntegerHash
, wxIntegerEqual
, myLongHashMap
);
1110 WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash
, wxIntegerEqual
,
1111 myUnsignedHashMap
);
1112 WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash
, wxIntegerEqual
,
1114 WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash
, wxIntegerEqual
,
1116 WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash
, wxIntegerEqual
,
1118 WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash
, wxIntegerEqual
,
1120 WX_DECLARE_HASH_MAP( wxString
, wxString
, wxStringHash
, wxStringEqual
,
1123 typedef myStringHashMap::iterator Itor
;
1125 static void TestHashMap()
1127 puts("*** Testing wxHashMap ***\n");
1128 myStringHashMap
sh(0); // as small as possible
1131 const size_t count
= 10000;
1133 // init with some data
1134 for( i
= 0; i
< count
; ++i
)
1136 buf
.Printf(wxT("%d"), i
);
1137 sh
[buf
] = wxT("A") + buf
+ wxT("C");
1140 // test that insertion worked
1141 if( sh
.size() != count
)
1143 printf("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n", sh
.size(), count
);
1146 for( i
= 0; i
< count
; ++i
)
1148 buf
.Printf(wxT("%d"), i
);
1149 if( sh
[buf
] != wxT("A") + buf
+ wxT("C") )
1151 printf("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n");
1156 // check that iterators work
1158 for( i
= 0, it
= sh
.begin(); it
!= sh
.end(); ++it
, ++i
)
1162 printf("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n");
1166 if( it
->second
!= sh
[it
->first
] )
1168 printf("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n");
1173 if( sh
.size() != i
)
1175 printf("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n", i
, count
);
1178 // test copy ctor, assignment operator
1179 myStringHashMap
h1( sh
), h2( 0 );
1182 for( i
= 0, it
= sh
.begin(); it
!= sh
.end(); ++it
, ++i
)
1184 if( h1
[it
->first
] != it
->second
)
1186 printf("*** ERROR: COPY CTOR BROKEN %s ***\n", it
->first
.c_str());
1189 if( h2
[it
->first
] != it
->second
)
1191 printf("*** ERROR: OPERATOR= BROKEN %s ***\n", it
->first
.c_str());
1196 for( i
= 0; i
< count
; ++i
)
1198 buf
.Printf(wxT("%d"), i
);
1199 size_t sz
= sh
.size();
1201 // test find() and erase(it)
1204 it
= sh
.find( buf
);
1205 if( it
!= sh
.end() )
1209 if( sh
.find( buf
) != sh
.end() )
1211 printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i
);
1215 printf("*** ERROR: CANT FIND ELEMENT %u ***\n", i
);
1220 size_t c
= sh
.erase( buf
);
1222 printf("*** ERROR: SHOULD RETURN 1 ***\n");
1224 if( sh
.find( buf
) != sh
.end() )
1226 printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i
);
1230 // count should decrease
1231 if( sh
.size() != sz
- 1 )
1233 printf("*** ERROR: COUNT DID NOT DECREASE ***\n");
1237 printf("*** Finished testing wxHashMap ***\n");
1242 // ----------------------------------------------------------------------------
1244 // ----------------------------------------------------------------------------
1248 #include "wx/list.h"
1250 WX_DECLARE_LIST(Bar
, wxListBars
);
1251 #include "wx/listimpl.cpp"
1252 WX_DEFINE_LIST(wxListBars
);
1254 static void TestListCtor()
1256 puts("*** Testing wxList construction ***\n");
1260 list1
.Append(new Bar(_T("first")));
1261 list1
.Append(new Bar(_T("second")));
1263 printf("After 1st list creation: %u objects in the list, %u objects total.\n",
1264 list1
.GetCount(), Bar::GetNumber());
1269 printf("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n",
1270 list1
.GetCount(), list2
.GetCount(), Bar::GetNumber());
1272 list1
.DeleteContents(TRUE
);
1275 printf("After list destruction: %u objects left.\n", Bar::GetNumber());
1280 // ----------------------------------------------------------------------------
1282 // ----------------------------------------------------------------------------
1286 #include "wx/intl.h"
1287 #include "wx/utils.h" // for wxSetEnv
1289 static wxLocale
gs_localeDefault(wxLANGUAGE_ENGLISH
);
1291 // find the name of the language from its value
1292 static const char *GetLangName(int lang
)
1294 static const char *languageNames
[] =
1315 "ARABIC_SAUDI_ARABIA",
1340 "CHINESE_SIMPLIFIED",
1341 "CHINESE_TRADITIONAL",
1344 "CHINESE_SINGAPORE",
1355 "ENGLISH_AUSTRALIA",
1359 "ENGLISH_CARIBBEAN",
1363 "ENGLISH_NEW_ZEALAND",
1364 "ENGLISH_PHILIPPINES",
1365 "ENGLISH_SOUTH_AFRICA",
1377 "FRENCH_LUXEMBOURG",
1386 "GERMAN_LIECHTENSTEIN",
1387 "GERMAN_LUXEMBOURG",
1428 "MALAY_BRUNEI_DARUSSALAM",
1440 "NORWEGIAN_NYNORSK",
1447 "PORTUGUESE_BRAZILIAN",
1472 "SPANISH_ARGENTINA",
1476 "SPANISH_COSTA_RICA",
1477 "SPANISH_DOMINICAN_REPUBLIC",
1479 "SPANISH_EL_SALVADOR",
1480 "SPANISH_GUATEMALA",
1484 "SPANISH_NICARAGUA",
1488 "SPANISH_PUERTO_RICO",
1491 "SPANISH_VENEZUELA",
1528 if ( (size_t)lang
< WXSIZEOF(languageNames
) )
1529 return languageNames
[lang
];
1534 static void TestDefaultLang()
1536 puts("*** Testing wxLocale::GetSystemLanguage ***");
1538 static const wxChar
*langStrings
[] =
1540 NULL
, // system default
1547 _T("de_DE.iso88591"),
1549 _T("?"), // invalid lang spec
1550 _T("klingonese"), // I bet on some systems it does exist...
1553 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1554 wxLocale::GetSystemEncodingName().c_str(),
1555 wxLocale::GetSystemEncoding());
1557 for ( size_t n
= 0; n
< WXSIZEOF(langStrings
); n
++ )
1559 const char *langStr
= langStrings
[n
];
1562 // FIXME: this doesn't do anything at all under Windows, we need
1563 // to create a new wxLocale!
1564 wxSetEnv(_T("LC_ALL"), langStr
);
1567 int lang
= gs_localeDefault
.GetSystemLanguage();
1568 printf("Locale for '%s' is %s.\n",
1569 langStr
? langStr
: "system default", GetLangName(lang
));
1573 #endif // TEST_LOCALE
1575 // ----------------------------------------------------------------------------
1577 // ----------------------------------------------------------------------------
1581 #include "wx/mimetype.h"
1583 static void TestMimeEnum()
1585 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1587 wxArrayString mimetypes
;
1589 size_t count
= wxTheMimeTypesManager
->EnumAllFileTypes(mimetypes
);
1591 printf("*** All %u known filetypes: ***\n", count
);
1596 for ( size_t n
= 0; n
< count
; n
++ )
1598 wxFileType
*filetype
=
1599 wxTheMimeTypesManager
->GetFileTypeFromMimeType(mimetypes
[n
]);
1602 printf("nothing known about the filetype '%s'!\n",
1603 mimetypes
[n
].c_str());
1607 filetype
->GetDescription(&desc
);
1608 filetype
->GetExtensions(exts
);
1610 filetype
->GetIcon(NULL
);
1613 for ( size_t e
= 0; e
< exts
.GetCount(); e
++ )
1616 extsAll
<< _T(", ");
1620 printf("\t%s: %s (%s)\n",
1621 mimetypes
[n
].c_str(), desc
.c_str(), extsAll
.c_str());
1627 static void TestMimeOverride()
1629 wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1631 static const wxChar
*mailcap
= _T("/tmp/mailcap");
1632 static const wxChar
*mimetypes
= _T("/tmp/mime.types");
1634 if ( wxFile::Exists(mailcap
) )
1635 wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1637 wxTheMimeTypesManager
->ReadMailcap(mailcap
) ? _T("ok") : _T("ERROR"));
1639 wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1642 if ( wxFile::Exists(mimetypes
) )
1643 wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1645 wxTheMimeTypesManager
->ReadMimeTypes(mimetypes
) ? _T("ok") : _T("ERROR"));
1647 wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1653 static void TestMimeFilename()
1655 wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1657 static const wxChar
*filenames
[] =
1664 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
1666 const wxString fname
= filenames
[n
];
1667 wxString ext
= fname
.AfterLast(_T('.'));
1668 wxFileType
*ft
= wxTheMimeTypesManager
->GetFileTypeFromExtension(ext
);
1671 wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext
.c_str());
1676 if ( !ft
->GetDescription(&desc
) )
1677 desc
= _T("<no description>");
1680 if ( !ft
->GetOpenCommand(&cmd
,
1681 wxFileType::MessageParameters(fname
, _T(""))) )
1682 cmd
= _T("<no command available>");
1684 wxPrintf(_T("To open %s (%s) do '%s'.\n"),
1685 fname
.c_str(), desc
.c_str(), cmd
.c_str());
1694 static void TestMimeAssociate()
1696 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1698 wxFileTypeInfo
ftInfo(
1699 _T("application/x-xyz"),
1700 _T("xyzview '%s'"), // open cmd
1701 _T(""), // print cmd
1702 _T("XYZ File") // description
1703 _T(".xyz"), // extensions
1704 NULL
// end of extensions
1706 ftInfo
.SetShortDesc(_T("XYZFile")); // used under Win32 only
1708 wxFileType
*ft
= wxTheMimeTypesManager
->Associate(ftInfo
);
1711 wxPuts(_T("ERROR: failed to create association!"));
1715 // TODO: read it back
1724 // ----------------------------------------------------------------------------
1725 // misc information functions
1726 // ----------------------------------------------------------------------------
1728 #ifdef TEST_INFO_FUNCTIONS
1730 #include "wx/utils.h"
1732 static void TestDiskInfo()
1734 puts("*** Testing wxGetDiskSpace() ***");
1739 printf("\nEnter a directory name: ");
1740 if ( !fgets(pathname
, WXSIZEOF(pathname
), stdin
) )
1743 // kill the last '\n'
1744 pathname
[strlen(pathname
) - 1] = 0;
1746 wxLongLong total
, free
;
1747 if ( !wxGetDiskSpace(pathname
, &total
, &free
) )
1749 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1753 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1754 (total
/ 1024).ToString().c_str(),
1755 (free
/ 1024).ToString().c_str(),
1761 static void TestOsInfo()
1763 puts("*** Testing OS info functions ***\n");
1766 wxGetOsVersion(&major
, &minor
);
1767 printf("Running under: %s, version %d.%d\n",
1768 wxGetOsDescription().c_str(), major
, minor
);
1770 printf("%ld free bytes of memory left.\n", wxGetFreeMemory());
1772 printf("Host name is %s (%s).\n",
1773 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1778 static void TestUserInfo()
1780 puts("*** Testing user info functions ***\n");
1782 printf("User id is:\t%s\n", wxGetUserId().c_str());
1783 printf("User name is:\t%s\n", wxGetUserName().c_str());
1784 printf("Home dir is:\t%s\n", wxGetHomeDir().c_str());
1785 printf("Email address:\t%s\n", wxGetEmailAddress().c_str());
1790 #endif // TEST_INFO_FUNCTIONS
1792 // ----------------------------------------------------------------------------
1794 // ----------------------------------------------------------------------------
1796 #ifdef TEST_LONGLONG
1798 #include "wx/longlong.h"
1799 #include "wx/timer.h"
1801 // make a 64 bit number from 4 16 bit ones
1802 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
1804 // get a random 64 bit number
1805 #define RAND_LL() MAKE_LL(rand(), rand(), rand(), rand())
1807 static const long testLongs
[] =
1818 #if wxUSE_LONGLONG_WX
1819 inline bool operator==(const wxLongLongWx
& a
, const wxLongLongNative
& b
)
1820 { return a
.GetHi() == b
.GetHi() && a
.GetLo() == b
.GetLo(); }
1821 inline bool operator==(const wxLongLongNative
& a
, const wxLongLongWx
& b
)
1822 { return a
.GetHi() == b
.GetHi() && a
.GetLo() == b
.GetLo(); }
1823 #endif // wxUSE_LONGLONG_WX
1825 static void TestSpeed()
1827 static const long max
= 100000000;
1834 for ( n
= 0; n
< max
; n
++ )
1839 printf("Summing longs took %ld milliseconds.\n", sw
.Time());
1842 #if wxUSE_LONGLONG_NATIVE
1847 for ( n
= 0; n
< max
; n
++ )
1852 printf("Summing wxLongLong_t took %ld milliseconds.\n", sw
.Time());
1854 #endif // wxUSE_LONGLONG_NATIVE
1860 for ( n
= 0; n
< max
; n
++ )
1865 printf("Summing wxLongLongs took %ld milliseconds.\n", sw
.Time());
1869 static void TestLongLongConversion()
1871 puts("*** Testing wxLongLong conversions ***\n");
1875 for ( size_t n
= 0; n
< 100000; n
++ )
1879 #if wxUSE_LONGLONG_NATIVE
1880 wxLongLongNative
b(a
.GetHi(), a
.GetLo());
1882 wxASSERT_MSG( a
== b
, "conversions failure" );
1884 puts("Can't do it without native long long type, test skipped.");
1887 #endif // wxUSE_LONGLONG_NATIVE
1889 if ( !(nTested
% 1000) )
1901 static void TestMultiplication()
1903 puts("*** Testing wxLongLong multiplication ***\n");
1907 for ( size_t n
= 0; n
< 100000; n
++ )
1912 #if wxUSE_LONGLONG_NATIVE
1913 wxLongLongNative
aa(a
.GetHi(), a
.GetLo());
1914 wxLongLongNative
bb(b
.GetHi(), b
.GetLo());
1916 wxASSERT_MSG( a
*b
== aa
*bb
, "multiplication failure" );
1917 #else // !wxUSE_LONGLONG_NATIVE
1918 puts("Can't do it without native long long type, test skipped.");
1921 #endif // wxUSE_LONGLONG_NATIVE
1923 if ( !(nTested
% 1000) )
1935 static void TestDivision()
1937 puts("*** Testing wxLongLong division ***\n");
1941 for ( size_t n
= 0; n
< 100000; n
++ )
1943 // get a random wxLongLong (shifting by 12 the MSB ensures that the
1944 // multiplication will not overflow)
1945 wxLongLong ll
= MAKE_LL((rand() >> 12), rand(), rand(), rand());
1947 // get a random long (not wxLongLong for now) to divide it with
1952 #if wxUSE_LONGLONG_NATIVE
1953 wxLongLongNative
m(ll
.GetHi(), ll
.GetLo());
1955 wxLongLongNative p
= m
/ l
, s
= m
% l
;
1956 wxASSERT_MSG( q
== p
&& r
== s
, "division failure" );
1957 #else // !wxUSE_LONGLONG_NATIVE
1958 // verify the result
1959 wxASSERT_MSG( ll
== q
*l
+ r
, "division failure" );
1960 #endif // wxUSE_LONGLONG_NATIVE
1962 if ( !(nTested
% 1000) )
1974 static void TestAddition()
1976 puts("*** Testing wxLongLong addition ***\n");
1980 for ( size_t n
= 0; n
< 100000; n
++ )
1986 #if wxUSE_LONGLONG_NATIVE
1987 wxASSERT_MSG( c
== wxLongLongNative(a
.GetHi(), a
.GetLo()) +
1988 wxLongLongNative(b
.GetHi(), b
.GetLo()),
1989 "addition failure" );
1990 #else // !wxUSE_LONGLONG_NATIVE
1991 wxASSERT_MSG( c
- b
== a
, "addition failure" );
1992 #endif // wxUSE_LONGLONG_NATIVE
1994 if ( !(nTested
% 1000) )
2006 static void TestBitOperations()
2008 puts("*** Testing wxLongLong bit operation ***\n");
2012 for ( size_t n
= 0; n
< 100000; n
++ )
2016 #if wxUSE_LONGLONG_NATIVE
2017 for ( size_t n
= 0; n
< 33; n
++ )
2020 #else // !wxUSE_LONGLONG_NATIVE
2021 puts("Can't do it without native long long type, test skipped.");
2024 #endif // wxUSE_LONGLONG_NATIVE
2026 if ( !(nTested
% 1000) )
2038 static void TestLongLongComparison()
2040 #if wxUSE_LONGLONG_WX
2041 puts("*** Testing wxLongLong comparison ***\n");
2043 static const long ls
[2] =
2049 wxLongLongWx lls
[2];
2053 for ( size_t n
= 0; n
< WXSIZEOF(testLongs
); n
++ )
2057 for ( size_t m
= 0; m
< WXSIZEOF(lls
); m
++ )
2059 res
= lls
[m
] > testLongs
[n
];
2060 printf("0x%lx > 0x%lx is %s (%s)\n",
2061 ls
[m
], testLongs
[n
], res
? "true" : "false",
2062 res
== (ls
[m
] > testLongs
[n
]) ? "ok" : "ERROR");
2064 res
= lls
[m
] < testLongs
[n
];
2065 printf("0x%lx < 0x%lx is %s (%s)\n",
2066 ls
[m
], testLongs
[n
], res
? "true" : "false",
2067 res
== (ls
[m
] < testLongs
[n
]) ? "ok" : "ERROR");
2069 res
= lls
[m
] == testLongs
[n
];
2070 printf("0x%lx == 0x%lx is %s (%s)\n",
2071 ls
[m
], testLongs
[n
], res
? "true" : "false",
2072 res
== (ls
[m
] == testLongs
[n
]) ? "ok" : "ERROR");
2075 #endif // wxUSE_LONGLONG_WX
2078 static void TestLongLongPrint()
2080 wxPuts(_T("*** Testing wxLongLong printing ***\n"));
2082 for ( size_t n
= 0; n
< WXSIZEOF(testLongs
); n
++ )
2084 wxLongLong ll
= testLongs
[n
];
2085 wxPrintf(_T("%ld == %s\n"), testLongs
[n
], ll
.ToString().c_str());
2088 wxLongLong
ll(0x12345678, 0x87654321);
2089 wxPrintf(_T("0x1234567887654321 = %s\n"), ll
.ToString().c_str());
2092 wxPrintf(_T("-0x1234567887654321 = %s\n"), ll
.ToString().c_str());
2098 #endif // TEST_LONGLONG
2100 // ----------------------------------------------------------------------------
2102 // ----------------------------------------------------------------------------
2104 #ifdef TEST_PATHLIST
2106 static void TestPathList()
2108 puts("*** Testing wxPathList ***\n");
2110 wxPathList pathlist
;
2111 pathlist
.AddEnvList("PATH");
2112 wxString path
= pathlist
.FindValidPath("ls");
2115 printf("ERROR: command not found in the path.\n");
2119 printf("Command found in the path as '%s'.\n", path
.c_str());
2123 #endif // TEST_PATHLIST
2125 // ----------------------------------------------------------------------------
2126 // regular expressions
2127 // ----------------------------------------------------------------------------
2131 #include "wx/regex.h"
2133 static void TestRegExCompile()
2135 wxPuts(_T("*** Testing RE compilation ***\n"));
2137 static struct RegExCompTestData
2139 const wxChar
*pattern
;
2141 } regExCompTestData
[] =
2143 { _T("foo"), TRUE
},
2144 { _T("foo("), FALSE
},
2145 { _T("foo(bar"), FALSE
},
2146 { _T("foo(bar)"), TRUE
},
2147 { _T("foo["), FALSE
},
2148 { _T("foo[bar"), FALSE
},
2149 { _T("foo[bar]"), TRUE
},
2150 { _T("foo{"), TRUE
},
2151 { _T("foo{1"), FALSE
},
2152 { _T("foo{bar"), TRUE
},
2153 { _T("foo{1}"), TRUE
},
2154 { _T("foo{1,2}"), TRUE
},
2155 { _T("foo{bar}"), TRUE
},
2156 { _T("foo*"), TRUE
},
2157 { _T("foo**"), FALSE
},
2158 { _T("foo+"), TRUE
},
2159 { _T("foo++"), FALSE
},
2160 { _T("foo?"), TRUE
},
2161 { _T("foo??"), FALSE
},
2162 { _T("foo?+"), FALSE
},
2166 for ( size_t n
= 0; n
< WXSIZEOF(regExCompTestData
); n
++ )
2168 const RegExCompTestData
& data
= regExCompTestData
[n
];
2169 bool ok
= re
.Compile(data
.pattern
);
2171 wxPrintf(_T("'%s' is %sa valid RE (%s)\n"),
2173 ok
? _T("") : _T("not "),
2174 ok
== data
.correct
? _T("ok") : _T("ERROR"));
2178 static void TestRegExMatch()
2180 wxPuts(_T("*** Testing RE matching ***\n"));
2182 static struct RegExMatchTestData
2184 const wxChar
*pattern
;
2187 } regExMatchTestData
[] =
2189 { _T("foo"), _T("bar"), FALSE
},
2190 { _T("foo"), _T("foobar"), TRUE
},
2191 { _T("^foo"), _T("foobar"), TRUE
},
2192 { _T("^foo"), _T("barfoo"), FALSE
},
2193 { _T("bar$"), _T("barbar"), TRUE
},
2194 { _T("bar$"), _T("barbar "), FALSE
},
2197 for ( size_t n
= 0; n
< WXSIZEOF(regExMatchTestData
); n
++ )
2199 const RegExMatchTestData
& data
= regExMatchTestData
[n
];
2201 wxRegEx
re(data
.pattern
);
2202 bool ok
= re
.Matches(data
.text
);
2204 wxPrintf(_T("'%s' %s %s (%s)\n"),
2206 ok
? _T("matches") : _T("doesn't match"),
2208 ok
== data
.correct
? _T("ok") : _T("ERROR"));
2212 static void TestRegExSubmatch()
2214 wxPuts(_T("*** Testing RE subexpressions ***\n"));
2216 wxRegEx
re(_T("([[:alpha:]]+) ([[:alpha:]]+) ([[:digit:]]+).*([[:digit:]]+)$"));
2217 if ( !re
.IsValid() )
2219 wxPuts(_T("ERROR: compilation failed."));
2223 wxString text
= _T("Fri Jul 13 18:37:52 CEST 2001");
2225 if ( !re
.Matches(text
) )
2227 wxPuts(_T("ERROR: match expected."));
2231 wxPrintf(_T("Entire match: %s\n"), re
.GetMatch(text
).c_str());
2233 wxPrintf(_T("Date: %s/%s/%s, wday: %s\n"),
2234 re
.GetMatch(text
, 3).c_str(),
2235 re
.GetMatch(text
, 2).c_str(),
2236 re
.GetMatch(text
, 4).c_str(),
2237 re
.GetMatch(text
, 1).c_str());
2241 static void TestRegExReplacement()
2243 wxPuts(_T("*** Testing RE replacement ***"));
2245 static struct RegExReplTestData
2249 const wxChar
*result
;
2251 } regExReplTestData
[] =
2253 { _T("foo123"), _T("bar"), _T("bar"), 1 },
2254 { _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
2255 { _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
2256 { _T("123foo"), _T("bar"), _T("123foo"), 0 },
2257 { _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
2258 { _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
2259 { _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
2262 const wxChar
*pattern
= _T("([a-z]+)[^0-9]*([0-9]+)");
2263 wxRegEx
re(pattern
);
2265 wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern
);
2267 for ( size_t n
= 0; n
< WXSIZEOF(regExReplTestData
); n
++ )
2269 const RegExReplTestData
& data
= regExReplTestData
[n
];
2271 wxString text
= data
.text
;
2272 size_t nRepl
= re
.Replace(&text
, data
.repl
);
2274 wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
2275 data
.text
, data
.repl
,
2276 nRepl
, nRepl
== 1 ? _T("") : _T("es"),
2278 if ( text
== data
.result
&& nRepl
== data
.count
)
2284 wxPrintf(_T("ERROR: should be %u and '%s')\n"),
2285 data
.count
, data
.result
);
2290 static void TestRegExInteractive()
2292 wxPuts(_T("*** Testing RE interactively ***"));
2297 printf("\nEnter a pattern: ");
2298 if ( !fgets(pattern
, WXSIZEOF(pattern
), stdin
) )
2301 // kill the last '\n'
2302 pattern
[strlen(pattern
) - 1] = 0;
2305 if ( !re
.Compile(pattern
) )
2313 printf("Enter text to match: ");
2314 if ( !fgets(text
, WXSIZEOF(text
), stdin
) )
2317 // kill the last '\n'
2318 text
[strlen(text
) - 1] = 0;
2320 if ( !re
.Matches(text
) )
2322 printf("No match.\n");
2326 printf("Pattern matches at '%s'\n", re
.GetMatch(text
).c_str());
2329 for ( size_t n
= 1; ; n
++ )
2331 if ( !re
.GetMatch(&start
, &len
, n
) )
2336 printf("Subexpr %u matched '%s'\n",
2337 n
, wxString(text
+ start
, len
).c_str());
2344 #endif // TEST_REGEX
2346 // ----------------------------------------------------------------------------
2348 // ----------------------------------------------------------------------------
2354 static void TestDbOpen()
2362 // ----------------------------------------------------------------------------
2363 // registry and related stuff
2364 // ----------------------------------------------------------------------------
2366 // this is for MSW only
2369 #undef TEST_REGISTRY
2374 #include "wx/confbase.h"
2375 #include "wx/msw/regconf.h"
2377 static void TestRegConfWrite()
2379 wxRegConfig
regconf(_T("console"), _T("wxwindows"));
2380 regconf
.Write(_T("Hello"), wxString(_T("world")));
2383 #endif // TEST_REGCONF
2385 #ifdef TEST_REGISTRY
2387 #include "wx/msw/registry.h"
2389 // I chose this one because I liked its name, but it probably only exists under
2391 static const wxChar
*TESTKEY
=
2392 _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2394 static void TestRegistryRead()
2396 puts("*** testing registry reading ***");
2398 wxRegKey
key(TESTKEY
);
2399 printf("The test key name is '%s'.\n", key
.GetName().c_str());
2402 puts("ERROR: test key can't be opened, aborting test.");
2407 size_t nSubKeys
, nValues
;
2408 if ( key
.GetKeyInfo(&nSubKeys
, NULL
, &nValues
, NULL
) )
2410 printf("It has %u subkeys and %u values.\n", nSubKeys
, nValues
);
2413 printf("Enumerating values:\n");
2417 bool cont
= key
.GetFirstValue(value
, dummy
);
2420 printf("Value '%s': type ", value
.c_str());
2421 switch ( key
.GetValueType(value
) )
2423 case wxRegKey::Type_None
: printf("ERROR (none)"); break;
2424 case wxRegKey::Type_String
: printf("SZ"); break;
2425 case wxRegKey::Type_Expand_String
: printf("EXPAND_SZ"); break;
2426 case wxRegKey::Type_Binary
: printf("BINARY"); break;
2427 case wxRegKey::Type_Dword
: printf("DWORD"); break;
2428 case wxRegKey::Type_Multi_String
: printf("MULTI_SZ"); break;
2429 default: printf("other (unknown)"); break;
2432 printf(", value = ");
2433 if ( key
.IsNumericValue(value
) )
2436 key
.QueryValue(value
, &val
);
2442 key
.QueryValue(value
, val
);
2443 printf("'%s'", val
.c_str());
2445 key
.QueryRawValue(value
, val
);
2446 printf(" (raw value '%s')", val
.c_str());
2451 cont
= key
.GetNextValue(value
, dummy
);
2455 static void TestRegistryAssociation()
2458 The second call to deleteself genertaes an error message, with a
2459 messagebox saying .flo is crucial to system operation, while the .ddf
2460 call also fails, but with no error message
2465 key
.SetName("HKEY_CLASSES_ROOT\\.ddf" );
2467 key
= "ddxf_auto_file" ;
2468 key
.SetName("HKEY_CLASSES_ROOT\\.flo" );
2470 key
= "ddxf_auto_file" ;
2471 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
2474 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
2476 key
= "program \"%1\"" ;
2478 key
.SetName("HKEY_CLASSES_ROOT\\.ddf" );
2480 key
.SetName("HKEY_CLASSES_ROOT\\.flo" );
2482 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
2484 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
2488 #endif // TEST_REGISTRY
2490 // ----------------------------------------------------------------------------
2492 // ----------------------------------------------------------------------------
2496 #include "wx/socket.h"
2497 #include "wx/protocol/protocol.h"
2498 #include "wx/protocol/http.h"
2500 static void TestSocketServer()
2502 puts("*** Testing wxSocketServer ***\n");
2504 static const int PORT
= 3000;
2509 wxSocketServer
*server
= new wxSocketServer(addr
);
2510 if ( !server
->Ok() )
2512 puts("ERROR: failed to bind");
2519 printf("Server: waiting for connection on port %d...\n", PORT
);
2521 wxSocketBase
*socket
= server
->Accept();
2524 puts("ERROR: wxSocketServer::Accept() failed.");
2528 puts("Server: got a client.");
2530 server
->SetTimeout(60); // 1 min
2532 while ( socket
->IsConnected() )
2538 if ( socket
->Read(&ch
, sizeof(ch
)).Error() )
2540 // don't log error if the client just close the connection
2541 if ( socket
->IsConnected() )
2543 puts("ERROR: in wxSocket::Read.");
2563 printf("Server: got '%s'.\n", s
.c_str());
2564 if ( s
== _T("bye") )
2571 socket
->Write(s
.MakeUpper().c_str(), s
.length());
2572 socket
->Write("\r\n", 2);
2573 printf("Server: wrote '%s'.\n", s
.c_str());
2576 puts("Server: lost a client.");
2581 // same as "delete server" but is consistent with GUI programs
2585 static void TestSocketClient()
2587 puts("*** Testing wxSocketClient ***\n");
2589 static const char *hostname
= "www.wxwindows.org";
2592 addr
.Hostname(hostname
);
2595 printf("--- Attempting to connect to %s:80...\n", hostname
);
2597 wxSocketClient client
;
2598 if ( !client
.Connect(addr
) )
2600 printf("ERROR: failed to connect to %s\n", hostname
);
2604 printf("--- Connected to %s:%u...\n",
2605 addr
.Hostname().c_str(), addr
.Service());
2609 // could use simply "GET" here I suppose
2611 wxString::Format("GET http://%s/\r\n", hostname
);
2612 client
.Write(cmdGet
, cmdGet
.length());
2613 printf("--- Sent command '%s' to the server\n",
2614 MakePrintable(cmdGet
).c_str());
2615 client
.Read(buf
, WXSIZEOF(buf
));
2616 printf("--- Server replied:\n%s", buf
);
2620 #endif // TEST_SOCKETS
2622 // ----------------------------------------------------------------------------
2624 // ----------------------------------------------------------------------------
2628 #include "wx/protocol/ftp.h"
2632 #define FTP_ANONYMOUS
2634 #ifdef FTP_ANONYMOUS
2635 static const char *directory
= "/pub";
2636 static const char *filename
= "welcome.msg";
2638 static const char *directory
= "/etc";
2639 static const char *filename
= "issue";
2642 static bool TestFtpConnect()
2644 puts("*** Testing FTP connect ***");
2646 #ifdef FTP_ANONYMOUS
2647 static const char *hostname
= "ftp.wxwindows.org";
2649 printf("--- Attempting to connect to %s:21 anonymously...\n", hostname
);
2650 #else // !FTP_ANONYMOUS
2651 static const char *hostname
= "localhost";
2654 fgets(user
, WXSIZEOF(user
), stdin
);
2655 user
[strlen(user
) - 1] = '\0'; // chop off '\n'
2659 printf("Password for %s: ", password
);
2660 fgets(password
, WXSIZEOF(password
), stdin
);
2661 password
[strlen(password
) - 1] = '\0'; // chop off '\n'
2662 ftp
.SetPassword(password
);
2664 printf("--- Attempting to connect to %s:21 as %s...\n", hostname
, user
);
2665 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2667 if ( !ftp
.Connect(hostname
) )
2669 printf("ERROR: failed to connect to %s\n", hostname
);
2675 printf("--- Connected to %s, current directory is '%s'\n",
2676 hostname
, ftp
.Pwd().c_str());
2682 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2683 static void TestFtpWuFtpd()
2686 static const char *hostname
= "ftp.eudora.com";
2687 if ( !ftp
.Connect(hostname
) )
2689 printf("ERROR: failed to connect to %s\n", hostname
);
2693 static const char *filename
= "eudora/pubs/draft-gellens-submit-09.txt";
2694 wxInputStream
*in
= ftp
.GetInputStream(filename
);
2697 printf("ERROR: couldn't get input stream for %s\n", filename
);
2701 size_t size
= in
->StreamSize();
2702 printf("Reading file %s (%u bytes)...", filename
, size
);
2704 char *data
= new char[size
];
2705 if ( !in
->Read(data
, size
) )
2707 puts("ERROR: read error");
2711 printf("Successfully retrieved the file.\n");
2720 static void TestFtpList()
2722 puts("*** Testing wxFTP file listing ***\n");
2725 if ( !ftp
.ChDir(directory
) )
2727 printf("ERROR: failed to cd to %s\n", directory
);
2730 printf("Current directory is '%s'\n", ftp
.Pwd().c_str());
2732 // test NLIST and LIST
2733 wxArrayString files
;
2734 if ( !ftp
.GetFilesList(files
) )
2736 puts("ERROR: failed to get NLIST of files");
2740 printf("Brief list of files under '%s':\n", ftp
.Pwd().c_str());
2741 size_t count
= files
.GetCount();
2742 for ( size_t n
= 0; n
< count
; n
++ )
2744 printf("\t%s\n", files
[n
].c_str());
2746 puts("End of the file list");
2749 if ( !ftp
.GetDirList(files
) )
2751 puts("ERROR: failed to get LIST of files");
2755 printf("Detailed list of files under '%s':\n", ftp
.Pwd().c_str());
2756 size_t count
= files
.GetCount();
2757 for ( size_t n
= 0; n
< count
; n
++ )
2759 printf("\t%s\n", files
[n
].c_str());
2761 puts("End of the file list");
2764 if ( !ftp
.ChDir(_T("..")) )
2766 puts("ERROR: failed to cd to ..");
2769 printf("Current directory is '%s'\n", ftp
.Pwd().c_str());
2772 static void TestFtpDownload()
2774 puts("*** Testing wxFTP download ***\n");
2777 wxInputStream
*in
= ftp
.GetInputStream(filename
);
2780 printf("ERROR: couldn't get input stream for %s\n", filename
);
2784 size_t size
= in
->StreamSize();
2785 printf("Reading file %s (%u bytes)...", filename
, size
);
2788 char *data
= new char[size
];
2789 if ( !in
->Read(data
, size
) )
2791 puts("ERROR: read error");
2795 printf("\nContents of %s:\n%s\n", filename
, data
);
2803 static void TestFtpFileSize()
2805 puts("*** Testing FTP SIZE command ***");
2807 if ( !ftp
.ChDir(directory
) )
2809 printf("ERROR: failed to cd to %s\n", directory
);
2812 printf("Current directory is '%s'\n", ftp
.Pwd().c_str());
2814 if ( ftp
.FileExists(filename
) )
2816 int size
= ftp
.GetFileSize(filename
);
2818 printf("ERROR: couldn't get size of '%s'\n", filename
);
2820 printf("Size of '%s' is %d bytes.\n", filename
, size
);
2824 printf("ERROR: '%s' doesn't exist\n", filename
);
2828 static void TestFtpMisc()
2830 puts("*** Testing miscellaneous wxFTP functions ***");
2832 if ( ftp
.SendCommand("STAT") != '2' )
2834 puts("ERROR: STAT failed");
2838 printf("STAT returned:\n\n%s\n", ftp
.GetLastResult().c_str());
2841 if ( ftp
.SendCommand("HELP SITE") != '2' )
2843 puts("ERROR: HELP SITE failed");
2847 printf("The list of site-specific commands:\n\n%s\n",
2848 ftp
.GetLastResult().c_str());
2852 static void TestFtpInteractive()
2854 puts("\n*** Interactive wxFTP test ***");
2860 printf("Enter FTP command: ");
2861 if ( !fgets(buf
, WXSIZEOF(buf
), stdin
) )
2864 // kill the last '\n'
2865 buf
[strlen(buf
) - 1] = 0;
2867 // special handling of LIST and NLST as they require data connection
2868 wxString
start(buf
, 4);
2870 if ( start
== "LIST" || start
== "NLST" )
2873 if ( strlen(buf
) > 4 )
2876 wxArrayString files
;
2877 if ( !ftp
.GetList(files
, wildcard
, start
== "LIST") )
2879 printf("ERROR: failed to get %s of files\n", start
.c_str());
2883 printf("--- %s of '%s' under '%s':\n",
2884 start
.c_str(), wildcard
.c_str(), ftp
.Pwd().c_str());
2885 size_t count
= files
.GetCount();
2886 for ( size_t n
= 0; n
< count
; n
++ )
2888 printf("\t%s\n", files
[n
].c_str());
2890 puts("--- End of the file list");
2895 char ch
= ftp
.SendCommand(buf
);
2896 printf("Command %s", ch
? "succeeded" : "failed");
2899 printf(" (return code %c)", ch
);
2902 printf(", server reply:\n%s\n\n", ftp
.GetLastResult().c_str());
2906 puts("\n*** done ***");
2909 static void TestFtpUpload()
2911 puts("*** Testing wxFTP uploading ***\n");
2914 static const char *file1
= "test1";
2915 static const char *file2
= "test2";
2916 wxOutputStream
*out
= ftp
.GetOutputStream(file1
);
2919 printf("--- Uploading to %s ---\n", file1
);
2920 out
->Write("First hello", 11);
2924 // send a command to check the remote file
2925 if ( ftp
.SendCommand(wxString("STAT ") + file1
) != '2' )
2927 printf("ERROR: STAT %s failed\n", file1
);
2931 printf("STAT %s returned:\n\n%s\n",
2932 file1
, ftp
.GetLastResult().c_str());
2935 out
= ftp
.GetOutputStream(file2
);
2938 printf("--- Uploading to %s ---\n", file1
);
2939 out
->Write("Second hello", 12);
2946 // ----------------------------------------------------------------------------
2948 // ----------------------------------------------------------------------------
2952 #include "wx/wfstream.h"
2953 #include "wx/mstream.h"
2955 static void TestFileStream()
2957 puts("*** Testing wxFileInputStream ***");
2959 static const wxChar
*filename
= _T("testdata.fs");
2961 wxFileOutputStream
fsOut(filename
);
2962 fsOut
.Write("foo", 3);
2965 wxFileInputStream
fsIn(filename
);
2966 printf("File stream size: %u\n", fsIn
.GetSize());
2967 while ( !fsIn
.Eof() )
2969 putchar(fsIn
.GetC());
2972 if ( !wxRemoveFile(filename
) )
2974 printf("ERROR: failed to remove the file '%s'.\n", filename
);
2977 puts("\n*** wxFileInputStream test done ***");
2980 static void TestMemoryStream()
2982 puts("*** Testing wxMemoryInputStream ***");
2985 wxStrncpy(buf
, _T("Hello, stream!"), WXSIZEOF(buf
));
2987 wxMemoryInputStream
memInpStream(buf
, wxStrlen(buf
));
2988 printf(_T("Memory stream size: %u\n"), memInpStream
.GetSize());
2989 while ( !memInpStream
.Eof() )
2991 putchar(memInpStream
.GetC());
2994 puts("\n*** wxMemoryInputStream test done ***");
2997 #endif // TEST_STREAMS
2999 // ----------------------------------------------------------------------------
3001 // ----------------------------------------------------------------------------
3005 #include "wx/timer.h"
3006 #include "wx/utils.h"
3008 static void TestStopWatch()
3010 puts("*** Testing wxStopWatch ***\n");
3013 printf("Sleeping 3 seconds...");
3015 printf("\telapsed time: %ldms\n", sw
.Time());
3018 printf("Sleeping 2 more seconds...");
3020 printf("\telapsed time: %ldms\n", sw
.Time());
3023 printf("And 3 more seconds...");
3025 printf("\telapsed time: %ldms\n", sw
.Time());
3028 puts("\nChecking for 'backwards clock' bug...");
3029 for ( size_t n
= 0; n
< 70; n
++ )
3033 for ( size_t m
= 0; m
< 100000; m
++ )
3035 if ( sw
.Time() < 0 || sw2
.Time() < 0 )
3037 puts("\ntime is negative - ERROR!");
3047 #endif // TEST_TIMER
3049 // ----------------------------------------------------------------------------
3051 // ----------------------------------------------------------------------------
3055 #include "wx/vcard.h"
3057 static void DumpVObject(size_t level
, const wxVCardObject
& vcard
)
3060 wxVCardObject
*vcObj
= vcard
.GetFirstProp(&cookie
);
3064 wxString(_T('\t'), level
).c_str(),
3065 vcObj
->GetName().c_str());
3068 switch ( vcObj
->GetType() )
3070 case wxVCardObject::String
:
3071 case wxVCardObject::UString
:
3074 vcObj
->GetValue(&val
);
3075 value
<< _T('"') << val
<< _T('"');
3079 case wxVCardObject::Int
:
3082 vcObj
->GetValue(&i
);
3083 value
.Printf(_T("%u"), i
);
3087 case wxVCardObject::Long
:
3090 vcObj
->GetValue(&l
);
3091 value
.Printf(_T("%lu"), l
);
3095 case wxVCardObject::None
:
3098 case wxVCardObject::Object
:
3099 value
= _T("<node>");
3103 value
= _T("<unknown value type>");
3107 printf(" = %s", value
.c_str());
3110 DumpVObject(level
+ 1, *vcObj
);
3113 vcObj
= vcard
.GetNextProp(&cookie
);
3117 static void DumpVCardAddresses(const wxVCard
& vcard
)
3119 puts("\nShowing all addresses from vCard:\n");
3123 wxVCardAddress
*addr
= vcard
.GetFirstAddress(&cookie
);
3127 int flags
= addr
->GetFlags();
3128 if ( flags
& wxVCardAddress::Domestic
)
3130 flagsStr
<< _T("domestic ");
3132 if ( flags
& wxVCardAddress::Intl
)
3134 flagsStr
<< _T("international ");
3136 if ( flags
& wxVCardAddress::Postal
)
3138 flagsStr
<< _T("postal ");
3140 if ( flags
& wxVCardAddress::Parcel
)
3142 flagsStr
<< _T("parcel ");
3144 if ( flags
& wxVCardAddress::Home
)
3146 flagsStr
<< _T("home ");
3148 if ( flags
& wxVCardAddress::Work
)
3150 flagsStr
<< _T("work ");
3153 printf("Address %u:\n"
3155 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3158 addr
->GetPostOffice().c_str(),
3159 addr
->GetExtAddress().c_str(),
3160 addr
->GetStreet().c_str(),
3161 addr
->GetLocality().c_str(),
3162 addr
->GetRegion().c_str(),
3163 addr
->GetPostalCode().c_str(),
3164 addr
->GetCountry().c_str()
3168 addr
= vcard
.GetNextAddress(&cookie
);
3172 static void DumpVCardPhoneNumbers(const wxVCard
& vcard
)
3174 puts("\nShowing all phone numbers from vCard:\n");
3178 wxVCardPhoneNumber
*phone
= vcard
.GetFirstPhoneNumber(&cookie
);
3182 int flags
= phone
->GetFlags();
3183 if ( flags
& wxVCardPhoneNumber::Voice
)
3185 flagsStr
<< _T("voice ");
3187 if ( flags
& wxVCardPhoneNumber::Fax
)
3189 flagsStr
<< _T("fax ");
3191 if ( flags
& wxVCardPhoneNumber::Cellular
)
3193 flagsStr
<< _T("cellular ");
3195 if ( flags
& wxVCardPhoneNumber::Modem
)
3197 flagsStr
<< _T("modem ");
3199 if ( flags
& wxVCardPhoneNumber::Home
)
3201 flagsStr
<< _T("home ");
3203 if ( flags
& wxVCardPhoneNumber::Work
)
3205 flagsStr
<< _T("work ");
3208 printf("Phone number %u:\n"
3213 phone
->GetNumber().c_str()
3217 phone
= vcard
.GetNextPhoneNumber(&cookie
);
3221 static void TestVCardRead()
3223 puts("*** Testing wxVCard reading ***\n");
3225 wxVCard
vcard(_T("vcard.vcf"));
3226 if ( !vcard
.IsOk() )
3228 puts("ERROR: couldn't load vCard.");
3232 // read individual vCard properties
3233 wxVCardObject
*vcObj
= vcard
.GetProperty("FN");
3237 vcObj
->GetValue(&value
);
3242 value
= _T("<none>");
3245 printf("Full name retrieved directly: %s\n", value
.c_str());
3248 if ( !vcard
.GetFullName(&value
) )
3250 value
= _T("<none>");
3253 printf("Full name from wxVCard API: %s\n", value
.c_str());
3255 // now show how to deal with multiply occuring properties
3256 DumpVCardAddresses(vcard
);
3257 DumpVCardPhoneNumbers(vcard
);
3259 // and finally show all
3260 puts("\nNow dumping the entire vCard:\n"
3261 "-----------------------------\n");
3263 DumpVObject(0, vcard
);
3267 static void TestVCardWrite()
3269 puts("*** Testing wxVCard writing ***\n");
3272 if ( !vcard
.IsOk() )
3274 puts("ERROR: couldn't create vCard.");
3279 vcard
.SetName("Zeitlin", "Vadim");
3280 vcard
.SetFullName("Vadim Zeitlin");
3281 vcard
.SetOrganization("wxWindows", "R&D");
3283 // just dump the vCard back
3284 puts("Entire vCard follows:\n");
3285 puts(vcard
.Write());
3289 #endif // TEST_VCARD
3291 // ----------------------------------------------------------------------------
3292 // wide char (Unicode) support
3293 // ----------------------------------------------------------------------------
3297 #include "wx/strconv.h"
3298 #include "wx/fontenc.h"
3299 #include "wx/encconv.h"
3300 #include "wx/buffer.h"
3302 static void TestUtf8()
3304 puts("*** Testing UTF8 support ***\n");
3306 static const char textInUtf8
[] =
3308 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3309 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3310 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3311 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3312 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3313 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3314 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3319 if ( wxConvUTF8
.MB2WC(wbuf
, textInUtf8
, WXSIZEOF(textInUtf8
)) <= 0 )
3321 puts("ERROR: UTF-8 decoding failed.");
3325 // using wxEncodingConverter
3327 wxEncodingConverter ec
;
3328 ec
.Init(wxFONTENCODING_UNICODE
, wxFONTENCODING_KOI8
);
3329 ec
.Convert(wbuf
, buf
);
3330 #else // using wxCSConv
3331 wxCSConv
conv(_T("koi8-r"));
3332 if ( conv
.WC2MB(buf
, wbuf
, 0 /* not needed wcslen(wbuf) */) <= 0 )
3334 puts("ERROR: conversion to KOI8-R failed.");
3339 printf("The resulting string (in koi8-r): %s\n", buf
);
3343 #endif // TEST_WCHAR
3345 // ----------------------------------------------------------------------------
3347 // ----------------------------------------------------------------------------
3351 #include "wx/filesys.h"
3352 #include "wx/fs_zip.h"
3353 #include "wx/zipstrm.h"
3355 static const wxChar
*TESTFILE_ZIP
= _T("testdata.zip");
3357 static void TestZipStreamRead()
3359 puts("*** Testing ZIP reading ***\n");
3361 static const wxChar
*filename
= _T("foo");
3362 wxZipInputStream
istr(TESTFILE_ZIP
, filename
);
3363 printf("Archive size: %u\n", istr
.GetSize());
3365 printf("Dumping the file '%s':\n", filename
);
3366 while ( !istr
.Eof() )
3368 putchar(istr
.GetC());
3372 puts("\n----- done ------");
3375 static void DumpZipDirectory(wxFileSystem
& fs
,
3376 const wxString
& dir
,
3377 const wxString
& indent
)
3379 wxString prefix
= wxString::Format(_T("%s#zip:%s"),
3380 TESTFILE_ZIP
, dir
.c_str());
3381 wxString wildcard
= prefix
+ _T("/*");
3383 wxString dirname
= fs
.FindFirst(wildcard
, wxDIR
);
3384 while ( !dirname
.empty() )
3386 if ( !dirname
.StartsWith(prefix
+ _T('/'), &dirname
) )
3388 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3393 wxPrintf(_T("%s%s\n"), indent
.c_str(), dirname
.c_str());
3395 DumpZipDirectory(fs
, dirname
,
3396 indent
+ wxString(_T(' '), 4));
3398 dirname
= fs
.FindNext();
3401 wxString filename
= fs
.FindFirst(wildcard
, wxFILE
);
3402 while ( !filename
.empty() )
3404 if ( !filename
.StartsWith(prefix
, &filename
) )
3406 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3411 wxPrintf(_T("%s%s\n"), indent
.c_str(), filename
.c_str());
3413 filename
= fs
.FindNext();
3417 static void TestZipFileSystem()
3419 puts("*** Testing ZIP file system ***\n");
3421 wxFileSystem::AddHandler(new wxZipFSHandler
);
3423 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP
);
3425 DumpZipDirectory(fs
, _T(""), wxString(_T(' '), 4));
3430 // ----------------------------------------------------------------------------
3432 // ----------------------------------------------------------------------------
3436 #include "wx/zstream.h"
3437 #include "wx/wfstream.h"
3439 static const wxChar
*FILENAME_GZ
= _T("test.gz");
3440 static const char *TEST_DATA
= "hello and hello again";
3442 static void TestZlibStreamWrite()
3444 puts("*** Testing Zlib stream reading ***\n");
3446 wxFileOutputStream
fileOutStream(FILENAME_GZ
);
3447 wxZlibOutputStream
ostr(fileOutStream
, 0);
3448 printf("Compressing the test string... ");
3449 ostr
.Write(TEST_DATA
, sizeof(TEST_DATA
));
3452 puts("(ERROR: failed)");
3459 puts("\n----- done ------");
3462 static void TestZlibStreamRead()
3464 puts("*** Testing Zlib stream reading ***\n");
3466 wxFileInputStream
fileInStream(FILENAME_GZ
);
3467 wxZlibInputStream
istr(fileInStream
);
3468 printf("Archive size: %u\n", istr
.GetSize());
3470 puts("Dumping the file:");
3471 while ( !istr
.Eof() )
3473 putchar(istr
.GetC());
3477 puts("\n----- done ------");
3482 // ----------------------------------------------------------------------------
3484 // ----------------------------------------------------------------------------
3486 #ifdef TEST_DATETIME
3490 #include "wx/date.h"
3491 #include "wx/datetime.h"
3496 wxDateTime::wxDateTime_t day
;
3497 wxDateTime::Month month
;
3499 wxDateTime::wxDateTime_t hour
, min
, sec
;
3501 wxDateTime::WeekDay wday
;
3502 time_t gmticks
, ticks
;
3504 void Init(const wxDateTime::Tm
& tm
)
3513 gmticks
= ticks
= -1;
3516 wxDateTime
DT() const
3517 { return wxDateTime(day
, month
, year
, hour
, min
, sec
); }
3519 bool SameDay(const wxDateTime::Tm
& tm
) const
3521 return day
== tm
.mday
&& month
== tm
.mon
&& year
== tm
.year
;
3524 wxString
Format() const
3527 s
.Printf("%02d:%02d:%02d %10s %02d, %4d%s",
3529 wxDateTime::GetMonthName(month
).c_str(),
3531 abs(wxDateTime::ConvertYearToBC(year
)),
3532 year
> 0 ? "AD" : "BC");
3536 wxString
FormatDate() const
3539 s
.Printf("%02d-%s-%4d%s",
3541 wxDateTime::GetMonthName(month
, wxDateTime::Name_Abbr
).c_str(),
3542 abs(wxDateTime::ConvertYearToBC(year
)),
3543 year
> 0 ? "AD" : "BC");
3548 static const Date testDates
[] =
3550 { 1, wxDateTime::Jan
, 1970, 00, 00, 00, 2440587.5, wxDateTime::Thu
, 0, -3600 },
3551 { 21, wxDateTime::Jan
, 2222, 00, 00, 00, 2532648.5, wxDateTime::Mon
, -1, -1 },
3552 { 29, wxDateTime::May
, 1976, 12, 00, 00, 2442928.0, wxDateTime::Sat
, 202219200, 202212000 },
3553 { 29, wxDateTime::Feb
, 1976, 00, 00, 00, 2442837.5, wxDateTime::Sun
, 194400000, 194396400 },
3554 { 1, wxDateTime::Jan
, 1900, 12, 00, 00, 2415021.0, wxDateTime::Mon
, -1, -1 },
3555 { 1, wxDateTime::Jan
, 1900, 00, 00, 00, 2415020.5, wxDateTime::Mon
, -1, -1 },
3556 { 15, wxDateTime::Oct
, 1582, 00, 00, 00, 2299160.5, wxDateTime::Fri
, -1, -1 },
3557 { 4, wxDateTime::Oct
, 1582, 00, 00, 00, 2299149.5, wxDateTime::Mon
, -1, -1 },
3558 { 1, wxDateTime::Mar
, 1, 00, 00, 00, 1721484.5, wxDateTime::Thu
, -1, -1 },
3559 { 1, wxDateTime::Jan
, 1, 00, 00, 00, 1721425.5, wxDateTime::Mon
, -1, -1 },
3560 { 31, wxDateTime::Dec
, 0, 00, 00, 00, 1721424.5, wxDateTime::Sun
, -1, -1 },
3561 { 1, wxDateTime::Jan
, 0, 00, 00, 00, 1721059.5, wxDateTime::Sat
, -1, -1 },
3562 { 12, wxDateTime::Aug
, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri
, -1, -1 },
3563 { 12, wxDateTime::Aug
, -4000, 00, 00, 00, 260313.5, wxDateTime::Sat
, -1, -1 },
3564 { 24, wxDateTime::Nov
, -4713, 00, 00, 00, -0.5, wxDateTime::Mon
, -1, -1 },
3567 // this test miscellaneous static wxDateTime functions
3568 static void TestTimeStatic()
3570 puts("\n*** wxDateTime static methods test ***");
3572 // some info about the current date
3573 int year
= wxDateTime::GetCurrentYear();
3574 printf("Current year %d is %sa leap one and has %d days.\n",
3576 wxDateTime::IsLeapYear(year
) ? "" : "not ",
3577 wxDateTime::GetNumberOfDays(year
));
3579 wxDateTime::Month month
= wxDateTime::GetCurrentMonth();
3580 printf("Current month is '%s' ('%s') and it has %d days\n",
3581 wxDateTime::GetMonthName(month
, wxDateTime::Name_Abbr
).c_str(),
3582 wxDateTime::GetMonthName(month
).c_str(),
3583 wxDateTime::GetNumberOfDays(month
));
3586 static const size_t nYears
= 5;
3587 static const size_t years
[2][nYears
] =
3589 // first line: the years to test
3590 { 1990, 1976, 2000, 2030, 1984, },
3592 // second line: TRUE if leap, FALSE otherwise
3593 { FALSE
, TRUE
, TRUE
, FALSE
, TRUE
}
3596 for ( size_t n
= 0; n
< nYears
; n
++ )
3598 int year
= years
[0][n
];
3599 bool should
= years
[1][n
] != 0,
3600 is
= wxDateTime::IsLeapYear(year
);
3602 printf("Year %d is %sa leap year (%s)\n",
3605 should
== is
? "ok" : "ERROR");
3607 wxASSERT( should
== wxDateTime::IsLeapYear(year
) );
3611 // test constructing wxDateTime objects
3612 static void TestTimeSet()
3614 puts("\n*** wxDateTime construction test ***");
3616 for ( size_t n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3618 const Date
& d1
= testDates
[n
];
3619 wxDateTime dt
= d1
.DT();
3622 d2
.Init(dt
.GetTm());
3624 wxString s1
= d1
.Format(),
3627 printf("Date: %s == %s (%s)\n",
3628 s1
.c_str(), s2
.c_str(),
3629 s1
== s2
? "ok" : "ERROR");
3633 // test time zones stuff
3634 static void TestTimeZones()
3636 puts("\n*** wxDateTime timezone test ***");
3638 wxDateTime now
= wxDateTime::Now();
3640 printf("Current GMT time:\t%s\n", now
.Format("%c", wxDateTime::GMT0
).c_str());
3641 printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::GMT0
).c_str());
3642 printf("Unix epoch (EST):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::EST
).c_str());
3643 printf("Current time in Paris:\t%s\n", now
.Format("%c", wxDateTime::CET
).c_str());
3644 printf(" Moscow:\t%s\n", now
.Format("%c", wxDateTime::MSK
).c_str());
3645 printf(" New York:\t%s\n", now
.Format("%c", wxDateTime::EST
).c_str());
3647 wxDateTime::Tm tm
= now
.GetTm();
3648 if ( wxDateTime(tm
) != now
)
3650 printf("ERROR: got %s instead of %s\n",
3651 wxDateTime(tm
).Format().c_str(), now
.Format().c_str());
3655 // test some minimal support for the dates outside the standard range
3656 static void TestTimeRange()
3658 puts("\n*** wxDateTime out-of-standard-range dates test ***");
3660 static const char *fmt
= "%d-%b-%Y %H:%M:%S";
3662 printf("Unix epoch:\t%s\n",
3663 wxDateTime(2440587.5).Format(fmt
).c_str());
3664 printf("Feb 29, 0: \t%s\n",
3665 wxDateTime(29, wxDateTime::Feb
, 0).Format(fmt
).c_str());
3666 printf("JDN 0: \t%s\n",
3667 wxDateTime(0.0).Format(fmt
).c_str());
3668 printf("Jan 1, 1AD:\t%s\n",
3669 wxDateTime(1, wxDateTime::Jan
, 1).Format(fmt
).c_str());
3670 printf("May 29, 2099:\t%s\n",
3671 wxDateTime(29, wxDateTime::May
, 2099).Format(fmt
).c_str());
3674 static void TestTimeTicks()
3676 puts("\n*** wxDateTime ticks test ***");
3678 for ( size_t n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3680 const Date
& d
= testDates
[n
];
3681 if ( d
.ticks
== -1 )
3684 wxDateTime dt
= d
.DT();
3685 long ticks
= (dt
.GetValue() / 1000).ToLong();
3686 printf("Ticks of %s:\t% 10ld", d
.Format().c_str(), ticks
);
3687 if ( ticks
== d
.ticks
)
3693 printf(" (ERROR: should be %ld, delta = %ld)\n",
3694 d
.ticks
, ticks
- d
.ticks
);
3697 dt
= d
.DT().ToTimezone(wxDateTime::GMT0
);
3698 ticks
= (dt
.GetValue() / 1000).ToLong();
3699 printf("GMtks of %s:\t% 10ld", d
.Format().c_str(), ticks
);
3700 if ( ticks
== d
.gmticks
)
3706 printf(" (ERROR: should be %ld, delta = %ld)\n",
3707 d
.gmticks
, ticks
- d
.gmticks
);
3714 // test conversions to JDN &c
3715 static void TestTimeJDN()
3717 puts("\n*** wxDateTime to JDN test ***");
3719 for ( size_t n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3721 const Date
& d
= testDates
[n
];
3722 wxDateTime
dt(d
.day
, d
.month
, d
.year
, d
.hour
, d
.min
, d
.sec
);
3723 double jdn
= dt
.GetJulianDayNumber();
3725 printf("JDN of %s is:\t% 15.6f", d
.Format().c_str(), jdn
);
3732 printf(" (ERROR: should be %f, delta = %f)\n",
3733 d
.jdn
, jdn
- d
.jdn
);
3738 // test week days computation
3739 static void TestTimeWDays()
3741 puts("\n*** wxDateTime weekday test ***");
3743 // test GetWeekDay()
3745 for ( n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3747 const Date
& d
= testDates
[n
];
3748 wxDateTime
dt(d
.day
, d
.month
, d
.year
, d
.hour
, d
.min
, d
.sec
);
3750 wxDateTime::WeekDay wday
= dt
.GetWeekDay();
3753 wxDateTime::GetWeekDayName(wday
).c_str());
3754 if ( wday
== d
.wday
)
3760 printf(" (ERROR: should be %s)\n",
3761 wxDateTime::GetWeekDayName(d
.wday
).c_str());
3767 // test SetToWeekDay()
3768 struct WeekDateTestData
3770 Date date
; // the real date (precomputed)
3771 int nWeek
; // its week index in the month
3772 wxDateTime::WeekDay wday
; // the weekday
3773 wxDateTime::Month month
; // the month
3774 int year
; // and the year
3776 wxString
Format() const
3779 switch ( nWeek
< -1 ? -nWeek
: nWeek
)
3781 case 1: which
= "first"; break;
3782 case 2: which
= "second"; break;
3783 case 3: which
= "third"; break;
3784 case 4: which
= "fourth"; break;
3785 case 5: which
= "fifth"; break;
3787 case -1: which
= "last"; break;
3792 which
+= " from end";
3795 s
.Printf("The %s %s of %s in %d",
3797 wxDateTime::GetWeekDayName(wday
).c_str(),
3798 wxDateTime::GetMonthName(month
).c_str(),
3805 // the array data was generated by the following python program
3807 from DateTime import *
3808 from whrandom import *
3809 from string import *
3811 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
3812 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
3814 week = DateTimeDelta(7)
3817 year = randint(1900, 2100)
3818 month = randint(1, 12)
3819 day = randint(1, 28)
3820 dt = DateTime(year, month, day)
3821 wday = dt.day_of_week
3823 countFromEnd = choice([-1, 1])
3826 while dt.month is month:
3827 dt = dt - countFromEnd * week
3828 weekNum = weekNum + countFromEnd
3830 data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
3832 print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
3833 "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
3836 static const WeekDateTestData weekDatesTestData
[] =
3838 { { 20, wxDateTime::Mar
, 2045 }, 3, wxDateTime::Mon
, wxDateTime::Mar
, 2045 },
3839 { { 5, wxDateTime::Jun
, 1985 }, -4, wxDateTime::Wed
, wxDateTime::Jun
, 1985 },
3840 { { 12, wxDateTime::Nov
, 1961 }, -3, wxDateTime::Sun
, wxDateTime::Nov
, 1961 },
3841 { { 27, wxDateTime::Feb
, 2093 }, -1, wxDateTime::Fri
, wxDateTime::Feb
, 2093 },
3842 { { 4, wxDateTime::Jul
, 2070 }, -4, wxDateTime::Fri
, wxDateTime::Jul
, 2070 },
3843 { { 2, wxDateTime::Apr
, 1906 }, -5, wxDateTime::Mon
, wxDateTime::Apr
, 1906 },
3844 { { 19, wxDateTime::Jul
, 2023 }, -2, wxDateTime::Wed
, wxDateTime::Jul
, 2023 },
3845 { { 5, wxDateTime::May
, 1958 }, -4, wxDateTime::Mon
, wxDateTime::May
, 1958 },
3846 { { 11, wxDateTime::Aug
, 1900 }, 2, wxDateTime::Sat
, wxDateTime::Aug
, 1900 },
3847 { { 14, wxDateTime::Feb
, 1945 }, 2, wxDateTime::Wed
, wxDateTime::Feb
, 1945 },
3848 { { 25, wxDateTime::Jul
, 1967 }, -1, wxDateTime::Tue
, wxDateTime::Jul
, 1967 },
3849 { { 9, wxDateTime::May
, 1916 }, -4, wxDateTime::Tue
, wxDateTime::May
, 1916 },
3850 { { 20, wxDateTime::Jun
, 1927 }, 3, wxDateTime::Mon
, wxDateTime::Jun
, 1927 },
3851 { { 2, wxDateTime::Aug
, 2000 }, 1, wxDateTime::Wed
, wxDateTime::Aug
, 2000 },
3852 { { 20, wxDateTime::Apr
, 2044 }, 3, wxDateTime::Wed
, wxDateTime::Apr
, 2044 },
3853 { { 20, wxDateTime::Feb
, 1932 }, -2, wxDateTime::Sat
, wxDateTime::Feb
, 1932 },
3854 { { 25, wxDateTime::Jul
, 2069 }, 4, wxDateTime::Thu
, wxDateTime::Jul
, 2069 },
3855 { { 3, wxDateTime::Apr
, 1925 }, 1, wxDateTime::Fri
, wxDateTime::Apr
, 1925 },
3856 { { 21, wxDateTime::Mar
, 2093 }, 3, wxDateTime::Sat
, wxDateTime::Mar
, 2093 },
3857 { { 3, wxDateTime::Dec
, 2074 }, -5, wxDateTime::Mon
, wxDateTime::Dec
, 2074 },
3860 static const char *fmt
= "%d-%b-%Y";
3863 for ( n
= 0; n
< WXSIZEOF(weekDatesTestData
); n
++ )
3865 const WeekDateTestData
& wd
= weekDatesTestData
[n
];
3867 dt
.SetToWeekDay(wd
.wday
, wd
.nWeek
, wd
.month
, wd
.year
);
3869 printf("%s is %s", wd
.Format().c_str(), dt
.Format(fmt
).c_str());
3871 const Date
& d
= wd
.date
;
3872 if ( d
.SameDay(dt
.GetTm()) )
3878 dt
.Set(d
.day
, d
.month
, d
.year
);
3880 printf(" (ERROR: should be %s)\n", dt
.Format(fmt
).c_str());
3885 // test the computation of (ISO) week numbers
3886 static void TestTimeWNumber()
3888 puts("\n*** wxDateTime week number test ***");
3890 struct WeekNumberTestData
3892 Date date
; // the date
3893 wxDateTime::wxDateTime_t week
; // the week number in the year
3894 wxDateTime::wxDateTime_t wmon
; // the week number in the month
3895 wxDateTime::wxDateTime_t wmon2
; // same but week starts with Sun
3896 wxDateTime::wxDateTime_t dnum
; // day number in the year
3899 // data generated with the following python script:
3901 from DateTime import *
3902 from whrandom import *
3903 from string import *
3905 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
3906 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
3908 def GetMonthWeek(dt):
3909 weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
3910 if weekNumMonth < 0:
3911 weekNumMonth = weekNumMonth + 53
3914 def GetLastSundayBefore(dt):
3915 if dt.iso_week[2] == 7:
3918 return dt - DateTimeDelta(dt.iso_week[2])
3921 year = randint(1900, 2100)
3922 month = randint(1, 12)
3923 day = randint(1, 28)
3924 dt = DateTime(year, month, day)
3925 dayNum = dt.day_of_year
3926 weekNum = dt.iso_week[1]
3927 weekNumMonth = GetMonthWeek(dt)
3930 dtSunday = GetLastSundayBefore(dt)
3932 while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
3933 weekNumMonth2 = weekNumMonth2 + 1
3934 dtSunday = dtSunday - DateTimeDelta(7)
3936 data = { 'day': rjust(`day`, 2), \
3937 'month': monthNames[month - 1], \
3939 'weekNum': rjust(`weekNum`, 2), \
3940 'weekNumMonth': weekNumMonth, \
3941 'weekNumMonth2': weekNumMonth2, \
3942 'dayNum': rjust(`dayNum`, 3) }
3944 print " { { %(day)s, "\
3945 "wxDateTime::%(month)s, "\
3948 "%(weekNumMonth)s, "\
3949 "%(weekNumMonth2)s, "\
3950 "%(dayNum)s }," % data
3953 static const WeekNumberTestData weekNumberTestDates
[] =
3955 { { 27, wxDateTime::Dec
, 1966 }, 52, 5, 5, 361 },
3956 { { 22, wxDateTime::Jul
, 1926 }, 29, 4, 4, 203 },
3957 { { 22, wxDateTime::Oct
, 2076 }, 43, 4, 4, 296 },
3958 { { 1, wxDateTime::Jul
, 1967 }, 26, 1, 1, 182 },
3959 { { 8, wxDateTime::Nov
, 2004 }, 46, 2, 2, 313 },
3960 { { 21, wxDateTime::Mar
, 1920 }, 12, 3, 4, 81 },
3961 { { 7, wxDateTime::Jan
, 1965 }, 1, 2, 2, 7 },
3962 { { 19, wxDateTime::Oct
, 1999 }, 42, 4, 4, 292 },
3963 { { 13, wxDateTime::Aug
, 1955 }, 32, 2, 2, 225 },
3964 { { 18, wxDateTime::Jul
, 2087 }, 29, 3, 3, 199 },
3965 { { 2, wxDateTime::Sep
, 2028 }, 35, 1, 1, 246 },
3966 { { 28, wxDateTime::Jul
, 1945 }, 30, 5, 4, 209 },
3967 { { 15, wxDateTime::Jun
, 1901 }, 24, 3, 3, 166 },
3968 { { 10, wxDateTime::Oct
, 1939 }, 41, 3, 2, 283 },
3969 { { 3, wxDateTime::Dec
, 1965 }, 48, 1, 1, 337 },
3970 { { 23, wxDateTime::Feb
, 1940 }, 8, 4, 4, 54 },
3971 { { 2, wxDateTime::Jan
, 1987 }, 1, 1, 1, 2 },
3972 { { 11, wxDateTime::Aug
, 2079 }, 32, 2, 2, 223 },
3973 { { 2, wxDateTime::Feb
, 2063 }, 5, 1, 1, 33 },
3974 { { 16, wxDateTime::Oct
, 1942 }, 42, 3, 3, 289 },
3977 for ( size_t n
= 0; n
< WXSIZEOF(weekNumberTestDates
); n
++ )
3979 const WeekNumberTestData
& wn
= weekNumberTestDates
[n
];
3980 const Date
& d
= wn
.date
;
3982 wxDateTime dt
= d
.DT();
3984 wxDateTime::wxDateTime_t
3985 week
= dt
.GetWeekOfYear(wxDateTime::Monday_First
),
3986 wmon
= dt
.GetWeekOfMonth(wxDateTime::Monday_First
),
3987 wmon2
= dt
.GetWeekOfMonth(wxDateTime::Sunday_First
),
3988 dnum
= dt
.GetDayOfYear();
3990 printf("%s: the day number is %d",
3991 d
.FormatDate().c_str(), dnum
);
3992 if ( dnum
== wn
.dnum
)
3998 printf(" (ERROR: should be %d)", wn
.dnum
);
4001 printf(", week in month is %d", wmon
);
4002 if ( wmon
== wn
.wmon
)
4008 printf(" (ERROR: should be %d)", wn
.wmon
);
4011 printf(" or %d", wmon2
);
4012 if ( wmon2
== wn
.wmon2
)
4018 printf(" (ERROR: should be %d)", wn
.wmon2
);
4021 printf(", week in year is %d", week
);
4022 if ( week
== wn
.week
)
4028 printf(" (ERROR: should be %d)\n", wn
.week
);
4033 // test DST calculations
4034 static void TestTimeDST()
4036 puts("\n*** wxDateTime DST test ***");
4038 printf("DST is%s in effect now.\n\n",
4039 wxDateTime::Now().IsDST() ? "" : " not");
4041 // taken from http://www.energy.ca.gov/daylightsaving.html
4042 static const Date datesDST
[2][2004 - 1900 + 1] =
4045 { 1, wxDateTime::Apr
, 1990 },
4046 { 7, wxDateTime::Apr
, 1991 },
4047 { 5, wxDateTime::Apr
, 1992 },
4048 { 4, wxDateTime::Apr
, 1993 },
4049 { 3, wxDateTime::Apr
, 1994 },
4050 { 2, wxDateTime::Apr
, 1995 },
4051 { 7, wxDateTime::Apr
, 1996 },
4052 { 6, wxDateTime::Apr
, 1997 },
4053 { 5, wxDateTime::Apr
, 1998 },
4054 { 4, wxDateTime::Apr
, 1999 },
4055 { 2, wxDateTime::Apr
, 2000 },
4056 { 1, wxDateTime::Apr
, 2001 },
4057 { 7, wxDateTime::Apr
, 2002 },
4058 { 6, wxDateTime::Apr
, 2003 },
4059 { 4, wxDateTime::Apr
, 2004 },
4062 { 28, wxDateTime::Oct
, 1990 },
4063 { 27, wxDateTime::Oct
, 1991 },
4064 { 25, wxDateTime::Oct
, 1992 },
4065 { 31, wxDateTime::Oct
, 1993 },
4066 { 30, wxDateTime::Oct
, 1994 },
4067 { 29, wxDateTime::Oct
, 1995 },
4068 { 27, wxDateTime::Oct
, 1996 },
4069 { 26, wxDateTime::Oct
, 1997 },
4070 { 25, wxDateTime::Oct
, 1998 },
4071 { 31, wxDateTime::Oct
, 1999 },
4072 { 29, wxDateTime::Oct
, 2000 },
4073 { 28, wxDateTime::Oct
, 2001 },
4074 { 27, wxDateTime::Oct
, 2002 },
4075 { 26, wxDateTime::Oct
, 2003 },
4076 { 31, wxDateTime::Oct
, 2004 },
4081 for ( year
= 1990; year
< 2005; year
++ )
4083 wxDateTime dtBegin
= wxDateTime::GetBeginDST(year
, wxDateTime::USA
),
4084 dtEnd
= wxDateTime::GetEndDST(year
, wxDateTime::USA
);
4086 printf("DST period in the US for year %d: from %s to %s",
4087 year
, dtBegin
.Format().c_str(), dtEnd
.Format().c_str());
4089 size_t n
= year
- 1990;
4090 const Date
& dBegin
= datesDST
[0][n
];
4091 const Date
& dEnd
= datesDST
[1][n
];
4093 if ( dBegin
.SameDay(dtBegin
.GetTm()) && dEnd
.SameDay(dtEnd
.GetTm()) )
4099 printf(" (ERROR: should be %s %d to %s %d)\n",
4100 wxDateTime::GetMonthName(dBegin
.month
).c_str(), dBegin
.day
,
4101 wxDateTime::GetMonthName(dEnd
.month
).c_str(), dEnd
.day
);
4107 for ( year
= 1990; year
< 2005; year
++ )
4109 printf("DST period in Europe for year %d: from %s to %s\n",
4111 wxDateTime::GetBeginDST(year
, wxDateTime::Country_EEC
).Format().c_str(),
4112 wxDateTime::GetEndDST(year
, wxDateTime::Country_EEC
).Format().c_str());
4116 // test wxDateTime -> text conversion
4117 static void TestTimeFormat()
4119 puts("\n*** wxDateTime formatting test ***");
4121 // some information may be lost during conversion, so store what kind
4122 // of info should we recover after a round trip
4125 CompareNone
, // don't try comparing
4126 CompareBoth
, // dates and times should be identical
4127 CompareDate
, // dates only
4128 CompareTime
// time only
4133 CompareKind compareKind
;
4135 } formatTestFormats
[] =
4137 { CompareBoth
, "---> %c" },
4138 { CompareDate
, "Date is %A, %d of %B, in year %Y" },
4139 { CompareBoth
, "Date is %x, time is %X" },
4140 { CompareTime
, "Time is %H:%M:%S or %I:%M:%S %p" },
4141 { CompareNone
, "The day of year: %j, the week of year: %W" },
4142 { CompareDate
, "ISO date without separators: %4Y%2m%2d" },
4145 static const Date formatTestDates
[] =
4147 { 29, wxDateTime::May
, 1976, 18, 30, 00 },
4148 { 31, wxDateTime::Dec
, 1999, 23, 30, 00 },
4150 // this test can't work for other centuries because it uses two digit
4151 // years in formats, so don't even try it
4152 { 29, wxDateTime::May
, 2076, 18, 30, 00 },
4153 { 29, wxDateTime::Feb
, 2400, 02, 15, 25 },
4154 { 01, wxDateTime::Jan
, -52, 03, 16, 47 },
4158 // an extra test (as it doesn't depend on date, don't do it in the loop)
4159 printf("%s\n", wxDateTime::Now().Format("Our timezone is %Z").c_str());
4161 for ( size_t d
= 0; d
< WXSIZEOF(formatTestDates
) + 1; d
++ )
4165 wxDateTime dt
= d
== 0 ? wxDateTime::Now() : formatTestDates
[d
- 1].DT();
4166 for ( size_t n
= 0; n
< WXSIZEOF(formatTestFormats
); n
++ )
4168 wxString s
= dt
.Format(formatTestFormats
[n
].format
);
4169 printf("%s", s
.c_str());
4171 // what can we recover?
4172 int kind
= formatTestFormats
[n
].compareKind
;
4176 const wxChar
*result
= dt2
.ParseFormat(s
, formatTestFormats
[n
].format
);
4179 // converion failed - should it have?
4180 if ( kind
== CompareNone
)
4183 puts(" (ERROR: conversion back failed)");
4187 // should have parsed the entire string
4188 puts(" (ERROR: conversion back stopped too soon)");
4192 bool equal
= FALSE
; // suppress compilaer warning
4200 equal
= dt
.IsSameDate(dt2
);
4204 equal
= dt
.IsSameTime(dt2
);
4210 printf(" (ERROR: got back '%s' instead of '%s')\n",
4211 dt2
.Format().c_str(), dt
.Format().c_str());
4222 // test text -> wxDateTime conversion
4223 static void TestTimeParse()
4225 puts("\n*** wxDateTime parse test ***");
4227 struct ParseTestData
4234 static const ParseTestData parseTestDates
[] =
4236 { "Sat, 18 Dec 1999 00:46:40 +0100", { 18, wxDateTime::Dec
, 1999, 00, 46, 40 }, TRUE
},
4237 { "Wed, 1 Dec 1999 05:17:20 +0300", { 1, wxDateTime::Dec
, 1999, 03, 17, 20 }, TRUE
},
4240 for ( size_t n
= 0; n
< WXSIZEOF(parseTestDates
); n
++ )
4242 const char *format
= parseTestDates
[n
].format
;
4244 printf("%s => ", format
);
4247 if ( dt
.ParseRfc822Date(format
) )
4249 printf("%s ", dt
.Format().c_str());
4251 if ( parseTestDates
[n
].good
)
4253 wxDateTime dtReal
= parseTestDates
[n
].date
.DT();
4260 printf("(ERROR: should be %s)\n", dtReal
.Format().c_str());
4265 puts("(ERROR: bad format)");
4270 printf("bad format (%s)\n",
4271 parseTestDates
[n
].good
? "ERROR" : "ok");
4276 static void TestDateTimeInteractive()
4278 puts("\n*** interactive wxDateTime tests ***");
4284 printf("Enter a date: ");
4285 if ( !fgets(buf
, WXSIZEOF(buf
), stdin
) )
4288 // kill the last '\n'
4289 buf
[strlen(buf
) - 1] = 0;
4292 const char *p
= dt
.ParseDate(buf
);
4295 printf("ERROR: failed to parse the date '%s'.\n", buf
);
4301 printf("WARNING: parsed only first %u characters.\n", p
- buf
);
4304 printf("%s: day %u, week of month %u/%u, week of year %u\n",
4305 dt
.Format("%b %d, %Y").c_str(),
4307 dt
.GetWeekOfMonth(wxDateTime::Monday_First
),
4308 dt
.GetWeekOfMonth(wxDateTime::Sunday_First
),
4309 dt
.GetWeekOfYear(wxDateTime::Monday_First
));
4312 puts("\n*** done ***");
4315 static void TestTimeMS()
4317 puts("*** testing millisecond-resolution support in wxDateTime ***");
4319 wxDateTime dt1
= wxDateTime::Now(),
4320 dt2
= wxDateTime::UNow();
4322 printf("Now = %s\n", dt1
.Format("%H:%M:%S:%l").c_str());
4323 printf("UNow = %s\n", dt2
.Format("%H:%M:%S:%l").c_str());
4324 printf("Dummy loop: ");
4325 for ( int i
= 0; i
< 6000; i
++ )
4327 //for ( int j = 0; j < 10; j++ )
4330 s
.Printf("%g", sqrt(i
));
4339 dt2
= wxDateTime::UNow();
4340 printf("UNow = %s\n", dt2
.Format("%H:%M:%S:%l").c_str());
4342 printf("Loop executed in %s ms\n", (dt2
- dt1
).Format("%l").c_str());
4344 puts("\n*** done ***");
4347 static void TestTimeArithmetics()
4349 puts("\n*** testing arithmetic operations on wxDateTime ***");
4351 static const struct ArithmData
4353 ArithmData(const wxDateSpan
& sp
, const char *nam
)
4354 : span(sp
), name(nam
) { }
4358 } testArithmData
[] =
4360 ArithmData(wxDateSpan::Day(), "day"),
4361 ArithmData(wxDateSpan::Week(), "week"),
4362 ArithmData(wxDateSpan::Month(), "month"),
4363 ArithmData(wxDateSpan::Year(), "year"),
4364 ArithmData(wxDateSpan(1, 2, 3, 4), "year, 2 months, 3 weeks, 4 days"),
4367 wxDateTime
dt(29, wxDateTime::Dec
, 1999), dt1
, dt2
;
4369 for ( size_t n
= 0; n
< WXSIZEOF(testArithmData
); n
++ )
4371 wxDateSpan span
= testArithmData
[n
].span
;
4375 const char *name
= testArithmData
[n
].name
;
4376 printf("%s + %s = %s, %s - %s = %s\n",
4377 dt
.FormatISODate().c_str(), name
, dt1
.FormatISODate().c_str(),
4378 dt
.FormatISODate().c_str(), name
, dt2
.FormatISODate().c_str());
4380 printf("Going back: %s", (dt1
- span
).FormatISODate().c_str());
4381 if ( dt1
- span
== dt
)
4387 printf(" (ERROR: should be %s)\n", dt
.FormatISODate().c_str());
4390 printf("Going forward: %s", (dt2
+ span
).FormatISODate().c_str());
4391 if ( dt2
+ span
== dt
)
4397 printf(" (ERROR: should be %s)\n", dt
.FormatISODate().c_str());
4400 printf("Double increment: %s", (dt2
+ 2*span
).FormatISODate().c_str());
4401 if ( dt2
+ 2*span
== dt1
)
4407 printf(" (ERROR: should be %s)\n", dt2
.FormatISODate().c_str());
4414 static void TestTimeHolidays()
4416 puts("\n*** testing wxDateTimeHolidayAuthority ***\n");
4418 wxDateTime::Tm tm
= wxDateTime(29, wxDateTime::May
, 2000).GetTm();
4419 wxDateTime
dtStart(1, tm
.mon
, tm
.year
),
4420 dtEnd
= dtStart
.GetLastMonthDay();
4422 wxDateTimeArray hol
;
4423 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart
, dtEnd
, hol
);
4425 const wxChar
*format
= "%d-%b-%Y (%a)";
4427 printf("All holidays between %s and %s:\n",
4428 dtStart
.Format(format
).c_str(), dtEnd
.Format(format
).c_str());
4430 size_t count
= hol
.GetCount();
4431 for ( size_t n
= 0; n
< count
; n
++ )
4433 printf("\t%s\n", hol
[n
].Format(format
).c_str());
4439 static void TestTimeZoneBug()
4441 puts("\n*** testing for DST/timezone bug ***\n");
4443 wxDateTime date
= wxDateTime(1, wxDateTime::Mar
, 2000);
4444 for ( int i
= 0; i
< 31; i
++ )
4446 printf("Date %s: week day %s.\n",
4447 date
.Format(_T("%d-%m-%Y")).c_str(),
4448 date
.GetWeekDayName(date
.GetWeekDay()).c_str());
4450 date
+= wxDateSpan::Day();
4456 static void TestTimeSpanFormat()
4458 puts("\n*** wxTimeSpan tests ***");
4460 static const char *formats
[] =
4462 _T("(default) %H:%M:%S"),
4463 _T("%E weeks and %D days"),
4464 _T("%l milliseconds"),
4465 _T("(with ms) %H:%M:%S:%l"),
4466 _T("100%% of minutes is %M"), // test "%%"
4467 _T("%D days and %H hours"),
4468 _T("or also %S seconds"),
4471 wxTimeSpan
ts1(1, 2, 3, 4),
4473 for ( size_t n
= 0; n
< WXSIZEOF(formats
); n
++ )
4475 printf("ts1 = %s\tts2 = %s\n",
4476 ts1
.Format(formats
[n
]).c_str(),
4477 ts2
.Format(formats
[n
]).c_str());
4485 // test compatibility with the old wxDate/wxTime classes
4486 static void TestTimeCompatibility()
4488 puts("\n*** wxDateTime compatibility test ***");
4490 printf("wxDate for JDN 0: %s\n", wxDate(0l).FormatDate().c_str());
4491 printf("wxDate for MJD 0: %s\n", wxDate(2400000).FormatDate().c_str());
4493 double jdnNow
= wxDateTime::Now().GetJDN();
4494 long jdnMidnight
= (long)(jdnNow
- 0.5);
4495 printf("wxDate for today: %s\n", wxDate(jdnMidnight
).FormatDate().c_str());
4497 jdnMidnight
= wxDate().Set().GetJulianDate();
4498 printf("wxDateTime for today: %s\n",
4499 wxDateTime((double)(jdnMidnight
+ 0.5)).Format("%c", wxDateTime::GMT0
).c_str());
4501 int flags
= wxEUROPEAN
;//wxFULL;
4504 printf("Today is %s\n", date
.FormatDate(flags
).c_str());
4505 for ( int n
= 0; n
< 7; n
++ )
4507 printf("Previous %s is %s\n",
4508 wxDateTime::GetWeekDayName((wxDateTime::WeekDay
)n
),
4509 date
.Previous(n
+ 1).FormatDate(flags
).c_str());
4515 #endif // TEST_DATETIME
4517 // ----------------------------------------------------------------------------
4519 // ----------------------------------------------------------------------------
4523 #include "wx/thread.h"
4525 static size_t gs_counter
= (size_t)-1;
4526 static wxCriticalSection gs_critsect
;
4527 static wxCondition gs_cond
;
4529 class MyJoinableThread
: public wxThread
4532 MyJoinableThread(size_t n
) : wxThread(wxTHREAD_JOINABLE
)
4533 { m_n
= n
; Create(); }
4535 // thread execution starts here
4536 virtual ExitCode
Entry();
4542 wxThread::ExitCode
MyJoinableThread::Entry()
4544 unsigned long res
= 1;
4545 for ( size_t n
= 1; n
< m_n
; n
++ )
4549 // it's a loooong calculation :-)
4553 return (ExitCode
)res
;
4556 class MyDetachedThread
: public wxThread
4559 MyDetachedThread(size_t n
, char ch
)
4563 m_cancelled
= FALSE
;
4568 // thread execution starts here
4569 virtual ExitCode
Entry();
4572 virtual void OnExit();
4575 size_t m_n
; // number of characters to write
4576 char m_ch
; // character to write
4578 bool m_cancelled
; // FALSE if we exit normally
4581 wxThread::ExitCode
MyDetachedThread::Entry()
4584 wxCriticalSectionLocker
lock(gs_critsect
);
4585 if ( gs_counter
== (size_t)-1 )
4591 for ( size_t n
= 0; n
< m_n
; n
++ )
4593 if ( TestDestroy() )
4603 wxThread::Sleep(100);
4609 void MyDetachedThread::OnExit()
4611 wxLogTrace("thread", "Thread %ld is in OnExit", GetId());
4613 wxCriticalSectionLocker
lock(gs_critsect
);
4614 if ( !--gs_counter
&& !m_cancelled
)
4618 static void TestDetachedThreads()
4620 puts("\n*** Testing detached threads ***");
4622 static const size_t nThreads
= 3;
4623 MyDetachedThread
*threads
[nThreads
];
4625 for ( n
= 0; n
< nThreads
; n
++ )
4627 threads
[n
] = new MyDetachedThread(10, 'A' + n
);
4630 threads
[0]->SetPriority(WXTHREAD_MIN_PRIORITY
);
4631 threads
[1]->SetPriority(WXTHREAD_MAX_PRIORITY
);
4633 for ( n
= 0; n
< nThreads
; n
++ )
4638 // wait until all threads terminate
4644 static void TestJoinableThreads()
4646 puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
4648 // calc 10! in the background
4649 MyJoinableThread
thread(10);
4652 printf("\nThread terminated with exit code %lu.\n",
4653 (unsigned long)thread
.Wait());
4656 static void TestThreadSuspend()
4658 puts("\n*** Testing thread suspend/resume functions ***");
4660 MyDetachedThread
*thread
= new MyDetachedThread(15, 'X');
4664 // this is for this demo only, in a real life program we'd use another
4665 // condition variable which would be signaled from wxThread::Entry() to
4666 // tell us that the thread really started running - but here just wait a
4667 // bit and hope that it will be enough (the problem is, of course, that
4668 // the thread might still not run when we call Pause() which will result
4670 wxThread::Sleep(300);
4672 for ( size_t n
= 0; n
< 3; n
++ )
4676 puts("\nThread suspended");
4679 // don't sleep but resume immediately the first time
4680 wxThread::Sleep(300);
4682 puts("Going to resume the thread");
4687 puts("Waiting until it terminates now");
4689 // wait until the thread terminates
4695 static void TestThreadDelete()
4697 // As above, using Sleep() is only for testing here - we must use some
4698 // synchronisation object instead to ensure that the thread is still
4699 // running when we delete it - deleting a detached thread which already
4700 // terminated will lead to a crash!
4702 puts("\n*** Testing thread delete function ***");
4704 MyDetachedThread
*thread0
= new MyDetachedThread(30, 'W');
4708 puts("\nDeleted a thread which didn't start to run yet.");
4710 MyDetachedThread
*thread1
= new MyDetachedThread(30, 'Y');
4714 wxThread::Sleep(300);
4718 puts("\nDeleted a running thread.");
4720 MyDetachedThread
*thread2
= new MyDetachedThread(30, 'Z');
4724 wxThread::Sleep(300);
4730 puts("\nDeleted a sleeping thread.");
4732 MyJoinableThread
thread3(20);
4737 puts("\nDeleted a joinable thread.");
4739 MyJoinableThread
thread4(2);
4742 wxThread::Sleep(300);
4746 puts("\nDeleted a joinable thread which already terminated.");
4751 class MyWaitingThread
: public wxThread
4754 MyWaitingThread(wxCondition
*condition
)
4756 m_condition
= condition
;
4761 virtual ExitCode
Entry()
4763 printf("Thread %lu has started running.\n", GetId());
4768 printf("Thread %lu starts to wait...\n", GetId());
4771 m_condition
->Wait();
4773 printf("Thread %lu finished to wait, exiting.\n", GetId());
4780 wxCondition
*m_condition
;
4783 static void TestThreadConditions()
4785 wxCondition condition
;
4787 // otherwise its difficult to understand which log messages pertain to
4789 wxLogTrace("thread", "Local condition var is %08x, gs_cond = %08x",
4790 condition
.GetId(), gs_cond
.GetId());
4792 // create and launch threads
4793 MyWaitingThread
*threads
[5];
4796 for ( n
= 0; n
< WXSIZEOF(threads
); n
++ )
4798 threads
[n
] = new MyWaitingThread(&condition
);
4801 for ( n
= 0; n
< WXSIZEOF(threads
); n
++ )
4806 // wait until all threads run
4807 puts("Main thread is waiting for the other threads to start");
4810 size_t nRunning
= 0;
4811 while ( nRunning
< WXSIZEOF(threads
) )
4817 printf("Main thread: %u already running\n", nRunning
);
4821 puts("Main thread: all threads started up.");
4824 wxThread::Sleep(500);
4827 // now wake one of them up
4828 printf("Main thread: about to signal the condition.\n");
4833 // wake all the (remaining) threads up, so that they can exit
4834 printf("Main thread: about to broadcast the condition.\n");
4836 condition
.Broadcast();
4838 // give them time to terminate (dirty!)
4839 wxThread::Sleep(500);
4842 #endif // TEST_THREADS
4844 // ----------------------------------------------------------------------------
4846 // ----------------------------------------------------------------------------
4850 static void PrintArray(const char* name
, const wxArrayString
& array
)
4852 printf("Dump of the array '%s'\n", name
);
4854 size_t nCount
= array
.GetCount();
4855 for ( size_t n
= 0; n
< nCount
; n
++ )
4857 printf("\t%s[%u] = '%s'\n", name
, n
, array
[n
].c_str());
4861 static void PrintArray(const char* name
, const wxArrayInt
& array
)
4863 printf("Dump of the array '%s'\n", name
);
4865 size_t nCount
= array
.GetCount();
4866 for ( size_t n
= 0; n
< nCount
; n
++ )
4868 printf("\t%s[%u] = %d\n", name
, n
, array
[n
]);
4872 int wxCMPFUNC_CONV
StringLenCompare(const wxString
& first
,
4873 const wxString
& second
)
4875 return first
.length() - second
.length();
4878 int wxCMPFUNC_CONV
IntCompare(int *first
,
4881 return *first
- *second
;
4884 int wxCMPFUNC_CONV
IntRevCompare(int *first
,
4887 return *second
- *first
;
4890 static void TestArrayOfInts()
4892 puts("*** Testing wxArrayInt ***\n");
4903 puts("After sort:");
4907 puts("After reverse sort:");
4908 a
.Sort(IntRevCompare
);
4912 #include "wx/dynarray.h"
4914 WX_DECLARE_OBJARRAY(Bar
, ArrayBars
);
4915 #include "wx/arrimpl.cpp"
4916 WX_DEFINE_OBJARRAY(ArrayBars
);
4918 static void TestArrayOfObjects()
4920 puts("*** Testing wxObjArray ***\n");
4924 Bar
bar("second bar");
4926 printf("Initially: %u objects in the array, %u objects total.\n",
4927 bars
.GetCount(), Bar::GetNumber());
4929 bars
.Add(new Bar("first bar"));
4932 printf("Now: %u objects in the array, %u objects total.\n",
4933 bars
.GetCount(), Bar::GetNumber());
4937 printf("After Empty(): %u objects in the array, %u objects total.\n",
4938 bars
.GetCount(), Bar::GetNumber());
4941 printf("Finally: no more objects in the array, %u objects total.\n",
4945 #endif // TEST_ARRAYS
4947 // ----------------------------------------------------------------------------
4949 // ----------------------------------------------------------------------------
4953 #include "wx/timer.h"
4954 #include "wx/tokenzr.h"
4956 static void TestStringConstruction()
4958 puts("*** Testing wxString constructores ***");
4960 #define TEST_CTOR(args, res) \
4963 printf("wxString%s = %s ", #args, s.c_str()); \
4970 printf("(ERROR: should be %s)\n", res); \
4974 TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
4975 TEST_CTOR((_T("Hello"), 4), _T("Hell"));
4976 TEST_CTOR((_T("Hello"), 5), _T("Hello"));
4977 // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
4979 static const wxChar
*s
= _T("?really!");
4980 const wxChar
*start
= wxStrchr(s
, _T('r'));
4981 const wxChar
*end
= wxStrchr(s
, _T('!'));
4982 TEST_CTOR((start
, end
), _T("really"));
4987 static void TestString()
4997 for (int i
= 0; i
< 1000000; ++i
)
5001 c
= "! How'ya doin'?";
5004 c
= "Hello world! What's up?";
5009 printf ("TestString elapsed time: %ld\n", sw
.Time());
5012 static void TestPChar()
5020 for (int i
= 0; i
< 1000000; ++i
)
5022 strcpy (a
, "Hello");
5023 strcpy (b
, " world");
5024 strcpy (c
, "! How'ya doin'?");
5027 strcpy (c
, "Hello world! What's up?");
5028 if (strcmp (c
, a
) == 0)
5032 printf ("TestPChar elapsed time: %ld\n", sw
.Time());
5035 static void TestStringSub()
5037 wxString
s("Hello, world!");
5039 puts("*** Testing wxString substring extraction ***");
5041 printf("String = '%s'\n", s
.c_str());
5042 printf("Left(5) = '%s'\n", s
.Left(5).c_str());
5043 printf("Right(6) = '%s'\n", s
.Right(6).c_str());
5044 printf("Mid(3, 5) = '%s'\n", s(3, 5).c_str());
5045 printf("Mid(3) = '%s'\n", s
.Mid(3).c_str());
5046 printf("substr(3, 5) = '%s'\n", s
.substr(3, 5).c_str());
5047 printf("substr(3) = '%s'\n", s
.substr(3).c_str());
5049 static const wxChar
*prefixes
[] =
5053 _T("Hello, world!"),
5054 _T("Hello, world!!!"),
5060 for ( size_t n
= 0; n
< WXSIZEOF(prefixes
); n
++ )
5062 wxString prefix
= prefixes
[n
], rest
;
5063 bool rc
= s
.StartsWith(prefix
, &rest
);
5064 printf("StartsWith('%s') = %s", prefix
.c_str(), rc
? "TRUE" : "FALSE");
5067 printf(" (the rest is '%s')\n", rest
.c_str());
5078 static void TestStringFormat()
5080 puts("*** Testing wxString formatting ***");
5083 s
.Printf("%03d", 18);
5085 printf("Number 18: %s\n", wxString::Format("%03d", 18).c_str());
5086 printf("Number 18: %s\n", s
.c_str());
5091 // returns "not found" for npos, value for all others
5092 static wxString
PosToString(size_t res
)
5094 wxString s
= res
== wxString::npos
? wxString(_T("not found"))
5095 : wxString::Format(_T("%u"), res
);
5099 static void TestStringFind()
5101 puts("*** Testing wxString find() functions ***");
5103 static const wxChar
*strToFind
= _T("ell");
5104 static const struct StringFindTest
5108 result
; // of searching "ell" in str
5111 { _T("Well, hello world"), 0, 1 },
5112 { _T("Well, hello world"), 6, 7 },
5113 { _T("Well, hello world"), 9, wxString::npos
},
5116 for ( size_t n
= 0; n
< WXSIZEOF(findTestData
); n
++ )
5118 const StringFindTest
& ft
= findTestData
[n
];
5119 size_t res
= wxString(ft
.str
).find(strToFind
, ft
.start
);
5121 printf(_T("Index of '%s' in '%s' starting from %u is %s "),
5122 strToFind
, ft
.str
, ft
.start
, PosToString(res
).c_str());
5124 size_t resTrue
= ft
.result
;
5125 if ( res
== resTrue
)
5131 printf(_T("(ERROR: should be %s)\n"),
5132 PosToString(resTrue
).c_str());
5139 static void TestStringTokenizer()
5141 puts("*** Testing wxStringTokenizer ***");
5143 static const wxChar
*modeNames
[] =
5147 _T("return all empty"),
5152 static const struct StringTokenizerTest
5154 const wxChar
*str
; // string to tokenize
5155 const wxChar
*delims
; // delimiters to use
5156 size_t count
; // count of token
5157 wxStringTokenizerMode mode
; // how should we tokenize it
5158 } tokenizerTestData
[] =
5160 { _T(""), _T(" "), 0 },
5161 { _T("Hello, world"), _T(" "), 2 },
5162 { _T("Hello, world "), _T(" "), 2 },
5163 { _T("Hello, world"), _T(","), 2 },
5164 { _T("Hello, world!"), _T(",!"), 2 },
5165 { _T("Hello,, world!"), _T(",!"), 3 },
5166 { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL
},
5167 { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
5168 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS
, 4 },
5169 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS
, 6, wxTOKEN_RET_EMPTY
},
5170 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS
, 9, wxTOKEN_RET_EMPTY_ALL
},
5171 { _T("01/02/99"), _T("/-"), 3 },
5172 { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS
},
5175 for ( size_t n
= 0; n
< WXSIZEOF(tokenizerTestData
); n
++ )
5177 const StringTokenizerTest
& tt
= tokenizerTestData
[n
];
5178 wxStringTokenizer
tkz(tt
.str
, tt
.delims
, tt
.mode
);
5180 size_t count
= tkz
.CountTokens();
5181 printf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
5182 MakePrintable(tt
.str
).c_str(),
5184 MakePrintable(tt
.delims
).c_str(),
5185 modeNames
[tkz
.GetMode()]);
5186 if ( count
== tt
.count
)
5192 printf(_T("(ERROR: should be %u)\n"), tt
.count
);
5197 // if we emulate strtok(), check that we do it correctly
5198 wxChar
*buf
, *s
= NULL
, *last
;
5200 if ( tkz
.GetMode() == wxTOKEN_STRTOK
)
5202 buf
= new wxChar
[wxStrlen(tt
.str
) + 1];
5203 wxStrcpy(buf
, tt
.str
);
5205 s
= wxStrtok(buf
, tt
.delims
, &last
);
5212 // now show the tokens themselves
5214 while ( tkz
.HasMoreTokens() )
5216 wxString token
= tkz
.GetNextToken();
5218 printf(_T("\ttoken %u: '%s'"),
5220 MakePrintable(token
).c_str());
5230 printf(" (ERROR: should be %s)\n", s
);
5233 s
= wxStrtok(NULL
, tt
.delims
, &last
);
5237 // nothing to compare with
5242 if ( count2
!= count
)
5244 puts(_T("\tERROR: token count mismatch"));
5253 static void TestStringReplace()
5255 puts("*** Testing wxString::replace ***");
5257 static const struct StringReplaceTestData
5259 const wxChar
*original
; // original test string
5260 size_t start
, len
; // the part to replace
5261 const wxChar
*replacement
; // the replacement string
5262 const wxChar
*result
; // and the expected result
5263 } stringReplaceTestData
[] =
5265 { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
5266 { _T("increase"), 0, 2, _T("de"), _T("decrease") },
5267 { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
5268 { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
5269 { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
5272 for ( size_t n
= 0; n
< WXSIZEOF(stringReplaceTestData
); n
++ )
5274 const StringReplaceTestData data
= stringReplaceTestData
[n
];
5276 wxString original
= data
.original
;
5277 original
.replace(data
.start
, data
.len
, data
.replacement
);
5279 wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
5280 data
.original
, data
.start
, data
.len
, data
.replacement
,
5283 if ( original
== data
.result
)
5289 wxPrintf(_T("(ERROR: should be '%s')\n"), data
.result
);
5296 static void TestStringMatch()
5298 wxPuts(_T("*** Testing wxString::Matches() ***"));
5300 static const struct StringMatchTestData
5303 const wxChar
*wildcard
;
5305 } stringMatchTestData
[] =
5307 { _T("foobar"), _T("foo*"), 1 },
5308 { _T("foobar"), _T("*oo*"), 1 },
5309 { _T("foobar"), _T("*bar"), 1 },
5310 { _T("foobar"), _T("??????"), 1 },
5311 { _T("foobar"), _T("f??b*"), 1 },
5312 { _T("foobar"), _T("f?b*"), 0 },
5313 { _T("foobar"), _T("*goo*"), 0 },
5314 { _T("foobar"), _T("*foo"), 0 },
5315 { _T("foobarfoo"), _T("*foo"), 1 },
5316 { _T(""), _T("*"), 1 },
5317 { _T(""), _T("?"), 0 },
5320 for ( size_t n
= 0; n
< WXSIZEOF(stringMatchTestData
); n
++ )
5322 const StringMatchTestData
& data
= stringMatchTestData
[n
];
5323 bool matches
= wxString(data
.text
).Matches(data
.wildcard
);
5324 wxPrintf(_T("'%s' %s '%s' (%s)\n"),
5326 matches
? _T("matches") : _T("doesn't match"),
5328 matches
== data
.matches
? _T("ok") : _T("ERROR"));
5334 #endif // TEST_STRINGS
5336 // ----------------------------------------------------------------------------
5338 // ----------------------------------------------------------------------------
5340 #ifdef TEST_SNGLINST
5341 #include "wx/snglinst.h"
5342 #endif // TEST_SNGLINST
5344 int main(int argc
, char **argv
)
5346 wxInitializer initializer
;
5349 fprintf(stderr
, "Failed to initialize the wxWindows library, aborting.");
5354 #ifdef TEST_SNGLINST
5355 wxSingleInstanceChecker checker
;
5356 if ( checker
.Create(_T(".wxconsole.lock")) )
5358 if ( checker
.IsAnotherRunning() )
5360 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
5365 // wait some time to give time to launch another instance
5366 wxPrintf(_T("Press \"Enter\" to continue..."));
5369 else // failed to create
5371 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
5373 #endif // TEST_SNGLINST
5377 #endif // TEST_CHARSET
5380 TestCmdLineConvert();
5382 #if wxUSE_CMDLINE_PARSER
5383 static const wxCmdLineEntryDesc cmdLineDesc
[] =
5385 { wxCMD_LINE_SWITCH
, _T("h"), _T("help"), "show this help message",
5386 wxCMD_LINE_VAL_NONE
, wxCMD_LINE_OPTION_HELP
},
5387 { wxCMD_LINE_SWITCH
, "v", "verbose", "be verbose" },
5388 { wxCMD_LINE_SWITCH
, "q", "quiet", "be quiet" },
5390 { wxCMD_LINE_OPTION
, "o", "output", "output file" },
5391 { wxCMD_LINE_OPTION
, "i", "input", "input dir" },
5392 { wxCMD_LINE_OPTION
, "s", "size", "output block size",
5393 wxCMD_LINE_VAL_NUMBER
},
5394 { wxCMD_LINE_OPTION
, "d", "date", "output file date",
5395 wxCMD_LINE_VAL_DATE
},
5397 { wxCMD_LINE_PARAM
, NULL
, NULL
, "input file",
5398 wxCMD_LINE_VAL_STRING
, wxCMD_LINE_PARAM_MULTIPLE
},
5403 wxCmdLineParser
parser(cmdLineDesc
, argc
, argv
);
5405 parser
.AddOption("project_name", "", "full path to project file",
5406 wxCMD_LINE_VAL_STRING
,
5407 wxCMD_LINE_OPTION_MANDATORY
| wxCMD_LINE_NEEDS_SEPARATOR
);
5409 switch ( parser
.Parse() )
5412 wxLogMessage("Help was given, terminating.");
5416 ShowCmdLine(parser
);
5420 wxLogMessage("Syntax error detected, aborting.");
5423 #endif // wxUSE_CMDLINE_PARSER
5425 #endif // TEST_CMDLINE
5433 TestStringConstruction();
5436 TestStringTokenizer();
5437 TestStringReplace();
5443 #endif // TEST_STRINGS
5456 puts("*** Initially:");
5458 PrintArray("a1", a1
);
5460 wxArrayString
a2(a1
);
5461 PrintArray("a2", a2
);
5463 wxSortedArrayString
a3(a1
);
5464 PrintArray("a3", a3
);
5466 puts("*** After deleting a string from a1");
5469 PrintArray("a1", a1
);
5470 PrintArray("a2", a2
);
5471 PrintArray("a3", a3
);
5473 puts("*** After reassigning a1 to a2 and a3");
5475 PrintArray("a2", a2
);
5476 PrintArray("a3", a3
);
5478 puts("*** After sorting a1");
5480 PrintArray("a1", a1
);
5482 puts("*** After sorting a1 in reverse order");
5484 PrintArray("a1", a1
);
5486 puts("*** After sorting a1 by the string length");
5487 a1
.Sort(StringLenCompare
);
5488 PrintArray("a1", a1
);
5490 TestArrayOfObjects();
5496 #endif // TEST_ARRAYS
5506 #ifdef TEST_DLLLOADER
5508 #endif // TEST_DLLLOADER
5512 #endif // TEST_ENVIRON
5516 #endif // TEST_EXECUTE
5518 #ifdef TEST_FILECONF
5520 #endif // TEST_FILECONF
5528 #endif // TEST_LOCALE
5532 for ( size_t n
= 0; n
< 8000; n
++ )
5534 s
<< (char)('A' + (n
% 26));
5538 msg
.Printf("A very very long message: '%s', the end!\n", s
.c_str());
5540 // this one shouldn't be truncated
5543 // but this one will because log functions use fixed size buffer
5544 // (note that it doesn't need '\n' at the end neither - will be added
5546 wxLogMessage("A very very long message 2: '%s', the end!", s
.c_str());
5558 #ifdef TEST_FILENAME
5562 fn
.Assign("c:\\foo", "bar.baz");
5569 TestFileNameConstruction();
5570 TestFileNameMakeRelative();
5571 TestFileNameSplit();
5574 TestFileNameComparison();
5575 TestFileNameOperations();
5577 #endif // TEST_FILENAME
5579 #ifdef TEST_FILETIME
5582 #endif // TEST_FILETIME
5585 wxLog::AddTraceMask(FTP_TRACE_MASK
);
5586 if ( TestFtpConnect() )
5597 if ( TEST_INTERACTIVE
)
5598 TestFtpInteractive();
5600 //else: connecting to the FTP server failed
5606 #ifdef TEST_LONGLONG
5607 // seed pseudo random generator
5608 srand((unsigned)time(NULL
));
5617 TestMultiplication();
5620 TestLongLongConversion();
5621 TestBitOperations();
5622 TestLongLongComparison();
5623 TestLongLongPrint();
5625 #endif // TEST_LONGLONG
5633 #endif // TEST_HASHMAP
5636 wxLog::AddTraceMask(_T("mime"));
5644 TestMimeAssociate();
5647 #ifdef TEST_INFO_FUNCTIONS
5654 #endif // TEST_INFO_FUNCTIONS
5656 #ifdef TEST_PATHLIST
5658 #endif // TEST_PATHLIST
5666 #endif // TEST_REGCONF
5669 // TODO: write a real test using src/regex/tests file
5674 TestRegExSubmatch();
5675 TestRegExReplacement();
5677 if ( TEST_INTERACTIVE
)
5678 TestRegExInteractive();
5680 #endif // TEST_REGEX
5682 #ifdef TEST_REGISTRY
5684 TestRegistryAssociation();
5685 #endif // TEST_REGISTRY
5690 #endif // TEST_SOCKETS
5695 #endif // TEST_STREAMS
5698 int nCPUs
= wxThread::GetCPUCount();
5699 printf("This system has %d CPUs\n", nCPUs
);
5701 wxThread::SetConcurrency(nCPUs
);
5705 TestDetachedThreads();
5706 TestJoinableThreads();
5707 TestThreadSuspend();
5711 TestThreadConditions();
5712 #endif // TEST_THREADS
5716 #endif // TEST_TIMER
5718 #ifdef TEST_DATETIME
5731 TestTimeArithmetics();
5734 TestTimeSpanFormat();
5740 if ( TEST_INTERACTIVE
)
5741 TestDateTimeInteractive();
5742 #endif // TEST_DATETIME
5745 puts("Sleeping for 3 seconds... z-z-z-z-z...");
5747 #endif // TEST_USLEEP
5752 #endif // TEST_VCARD
5756 #endif // TEST_WCHAR
5759 TestZipStreamRead();
5760 TestZipFileSystem();
5764 TestZlibStreamWrite();
5765 TestZlibStreamRead();