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
,
1122 // WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
1123 // myStringHashMap );
1124 WX_DECLARE_STRING_HASH_MAP(wxString
, myStringHashMap
);
1126 typedef myStringHashMap::iterator Itor
;
1128 static void TestHashMap()
1130 puts("*** Testing wxHashMap ***\n");
1131 myStringHashMap
sh(0); // as small as possible
1134 const size_t count
= 10000;
1136 // init with some data
1137 for( i
= 0; i
< count
; ++i
)
1139 buf
.Printf(wxT("%d"), i
);
1140 sh
[buf
] = wxT("A") + buf
+ wxT("C");
1143 // test that insertion worked
1144 if( sh
.size() != count
)
1146 printf("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n", sh
.size(), count
);
1149 for( i
= 0; i
< count
; ++i
)
1151 buf
.Printf(wxT("%d"), i
);
1152 if( sh
[buf
] != wxT("A") + buf
+ wxT("C") )
1154 printf("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n");
1159 // check that iterators work
1161 for( i
= 0, it
= sh
.begin(); it
!= sh
.end(); ++it
, ++i
)
1165 printf("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n");
1169 if( it
->second
!= sh
[it
->first
] )
1171 printf("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n");
1176 if( sh
.size() != i
)
1178 printf("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n", i
, count
);
1181 // test copy ctor, assignment operator
1182 myStringHashMap
h1( sh
), h2( 0 );
1185 for( i
= 0, it
= sh
.begin(); it
!= sh
.end(); ++it
, ++i
)
1187 if( h1
[it
->first
] != it
->second
)
1189 printf("*** ERROR: COPY CTOR BROKEN %s ***\n", it
->first
.c_str());
1192 if( h2
[it
->first
] != it
->second
)
1194 printf("*** ERROR: OPERATOR= BROKEN %s ***\n", it
->first
.c_str());
1199 for( i
= 0; i
< count
; ++i
)
1201 buf
.Printf(wxT("%d"), i
);
1202 size_t sz
= sh
.size();
1204 // test find() and erase(it)
1207 it
= sh
.find( buf
);
1208 if( it
!= sh
.end() )
1212 if( sh
.find( buf
) != sh
.end() )
1214 printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i
);
1218 printf("*** ERROR: CANT FIND ELEMENT %u ***\n", i
);
1223 size_t c
= sh
.erase( buf
);
1225 printf("*** ERROR: SHOULD RETURN 1 ***\n");
1227 if( sh
.find( buf
) != sh
.end() )
1229 printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i
);
1233 // count should decrease
1234 if( sh
.size() != sz
- 1 )
1236 printf("*** ERROR: COUNT DID NOT DECREASE ***\n");
1240 printf("*** Finished testing wxHashMap ***\n");
1243 #endif // TEST_HASHMAP
1245 // ----------------------------------------------------------------------------
1247 // ----------------------------------------------------------------------------
1251 #include "wx/list.h"
1253 WX_DECLARE_LIST(Bar
, wxListBars
);
1254 #include "wx/listimpl.cpp"
1255 WX_DEFINE_LIST(wxListBars
);
1257 static void TestListCtor()
1259 puts("*** Testing wxList construction ***\n");
1263 list1
.Append(new Bar(_T("first")));
1264 list1
.Append(new Bar(_T("second")));
1266 printf("After 1st list creation: %u objects in the list, %u objects total.\n",
1267 list1
.GetCount(), Bar::GetNumber());
1272 printf("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n",
1273 list1
.GetCount(), list2
.GetCount(), Bar::GetNumber());
1275 list1
.DeleteContents(TRUE
);
1278 printf("After list destruction: %u objects left.\n", Bar::GetNumber());
1283 // ----------------------------------------------------------------------------
1285 // ----------------------------------------------------------------------------
1289 #include "wx/intl.h"
1290 #include "wx/utils.h" // for wxSetEnv
1292 static wxLocale
gs_localeDefault(wxLANGUAGE_ENGLISH
);
1294 // find the name of the language from its value
1295 static const char *GetLangName(int lang
)
1297 static const char *languageNames
[] =
1318 "ARABIC_SAUDI_ARABIA",
1343 "CHINESE_SIMPLIFIED",
1344 "CHINESE_TRADITIONAL",
1347 "CHINESE_SINGAPORE",
1358 "ENGLISH_AUSTRALIA",
1362 "ENGLISH_CARIBBEAN",
1366 "ENGLISH_NEW_ZEALAND",
1367 "ENGLISH_PHILIPPINES",
1368 "ENGLISH_SOUTH_AFRICA",
1380 "FRENCH_LUXEMBOURG",
1389 "GERMAN_LIECHTENSTEIN",
1390 "GERMAN_LUXEMBOURG",
1431 "MALAY_BRUNEI_DARUSSALAM",
1443 "NORWEGIAN_NYNORSK",
1450 "PORTUGUESE_BRAZILIAN",
1475 "SPANISH_ARGENTINA",
1479 "SPANISH_COSTA_RICA",
1480 "SPANISH_DOMINICAN_REPUBLIC",
1482 "SPANISH_EL_SALVADOR",
1483 "SPANISH_GUATEMALA",
1487 "SPANISH_NICARAGUA",
1491 "SPANISH_PUERTO_RICO",
1494 "SPANISH_VENEZUELA",
1531 if ( (size_t)lang
< WXSIZEOF(languageNames
) )
1532 return languageNames
[lang
];
1537 static void TestDefaultLang()
1539 puts("*** Testing wxLocale::GetSystemLanguage ***");
1541 static const wxChar
*langStrings
[] =
1543 NULL
, // system default
1550 _T("de_DE.iso88591"),
1552 _T("?"), // invalid lang spec
1553 _T("klingonese"), // I bet on some systems it does exist...
1556 wxPrintf(_T("The default system encoding is %s (%d)\n"),
1557 wxLocale::GetSystemEncodingName().c_str(),
1558 wxLocale::GetSystemEncoding());
1560 for ( size_t n
= 0; n
< WXSIZEOF(langStrings
); n
++ )
1562 const char *langStr
= langStrings
[n
];
1565 // FIXME: this doesn't do anything at all under Windows, we need
1566 // to create a new wxLocale!
1567 wxSetEnv(_T("LC_ALL"), langStr
);
1570 int lang
= gs_localeDefault
.GetSystemLanguage();
1571 printf("Locale for '%s' is %s.\n",
1572 langStr
? langStr
: "system default", GetLangName(lang
));
1576 #endif // TEST_LOCALE
1578 // ----------------------------------------------------------------------------
1580 // ----------------------------------------------------------------------------
1584 #include "wx/mimetype.h"
1586 static void TestMimeEnum()
1588 wxPuts(_T("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));
1590 wxArrayString mimetypes
;
1592 size_t count
= wxTheMimeTypesManager
->EnumAllFileTypes(mimetypes
);
1594 printf("*** All %u known filetypes: ***\n", count
);
1599 for ( size_t n
= 0; n
< count
; n
++ )
1601 wxFileType
*filetype
=
1602 wxTheMimeTypesManager
->GetFileTypeFromMimeType(mimetypes
[n
]);
1605 printf("nothing known about the filetype '%s'!\n",
1606 mimetypes
[n
].c_str());
1610 filetype
->GetDescription(&desc
);
1611 filetype
->GetExtensions(exts
);
1613 filetype
->GetIcon(NULL
);
1616 for ( size_t e
= 0; e
< exts
.GetCount(); e
++ )
1619 extsAll
<< _T(", ");
1623 printf("\t%s: %s (%s)\n",
1624 mimetypes
[n
].c_str(), desc
.c_str(), extsAll
.c_str());
1630 static void TestMimeOverride()
1632 wxPuts(_T("*** Testing wxMimeTypesManager additional files loading ***\n"));
1634 static const wxChar
*mailcap
= _T("/tmp/mailcap");
1635 static const wxChar
*mimetypes
= _T("/tmp/mime.types");
1637 if ( wxFile::Exists(mailcap
) )
1638 wxPrintf(_T("Loading mailcap from '%s': %s\n"),
1640 wxTheMimeTypesManager
->ReadMailcap(mailcap
) ? _T("ok") : _T("ERROR"));
1642 wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
1645 if ( wxFile::Exists(mimetypes
) )
1646 wxPrintf(_T("Loading mime.types from '%s': %s\n"),
1648 wxTheMimeTypesManager
->ReadMimeTypes(mimetypes
) ? _T("ok") : _T("ERROR"));
1650 wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
1656 static void TestMimeFilename()
1658 wxPuts(_T("*** Testing MIME type from filename query ***\n"));
1660 static const wxChar
*filenames
[] =
1667 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
1669 const wxString fname
= filenames
[n
];
1670 wxString ext
= fname
.AfterLast(_T('.'));
1671 wxFileType
*ft
= wxTheMimeTypesManager
->GetFileTypeFromExtension(ext
);
1674 wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext
.c_str());
1679 if ( !ft
->GetDescription(&desc
) )
1680 desc
= _T("<no description>");
1683 if ( !ft
->GetOpenCommand(&cmd
,
1684 wxFileType::MessageParameters(fname
, _T(""))) )
1685 cmd
= _T("<no command available>");
1687 wxPrintf(_T("To open %s (%s) do '%s'.\n"),
1688 fname
.c_str(), desc
.c_str(), cmd
.c_str());
1697 static void TestMimeAssociate()
1699 wxPuts(_T("*** Testing creation of filetype association ***\n"));
1701 wxFileTypeInfo
ftInfo(
1702 _T("application/x-xyz"),
1703 _T("xyzview '%s'"), // open cmd
1704 _T(""), // print cmd
1705 _T("XYZ File") // description
1706 _T(".xyz"), // extensions
1707 NULL
// end of extensions
1709 ftInfo
.SetShortDesc(_T("XYZFile")); // used under Win32 only
1711 wxFileType
*ft
= wxTheMimeTypesManager
->Associate(ftInfo
);
1714 wxPuts(_T("ERROR: failed to create association!"));
1718 // TODO: read it back
1727 // ----------------------------------------------------------------------------
1728 // misc information functions
1729 // ----------------------------------------------------------------------------
1731 #ifdef TEST_INFO_FUNCTIONS
1733 #include "wx/utils.h"
1735 static void TestDiskInfo()
1737 puts("*** Testing wxGetDiskSpace() ***");
1742 printf("\nEnter a directory name: ");
1743 if ( !fgets(pathname
, WXSIZEOF(pathname
), stdin
) )
1746 // kill the last '\n'
1747 pathname
[strlen(pathname
) - 1] = 0;
1749 wxLongLong total
, free
;
1750 if ( !wxGetDiskSpace(pathname
, &total
, &free
) )
1752 wxPuts(_T("ERROR: wxGetDiskSpace failed."));
1756 wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
1757 (total
/ 1024).ToString().c_str(),
1758 (free
/ 1024).ToString().c_str(),
1764 static void TestOsInfo()
1766 puts("*** Testing OS info functions ***\n");
1769 wxGetOsVersion(&major
, &minor
);
1770 printf("Running under: %s, version %d.%d\n",
1771 wxGetOsDescription().c_str(), major
, minor
);
1773 printf("%ld free bytes of memory left.\n", wxGetFreeMemory());
1775 printf("Host name is %s (%s).\n",
1776 wxGetHostName().c_str(), wxGetFullHostName().c_str());
1781 static void TestUserInfo()
1783 puts("*** Testing user info functions ***\n");
1785 printf("User id is:\t%s\n", wxGetUserId().c_str());
1786 printf("User name is:\t%s\n", wxGetUserName().c_str());
1787 printf("Home dir is:\t%s\n", wxGetHomeDir().c_str());
1788 printf("Email address:\t%s\n", wxGetEmailAddress().c_str());
1793 #endif // TEST_INFO_FUNCTIONS
1795 // ----------------------------------------------------------------------------
1797 // ----------------------------------------------------------------------------
1799 #ifdef TEST_LONGLONG
1801 #include "wx/longlong.h"
1802 #include "wx/timer.h"
1804 // make a 64 bit number from 4 16 bit ones
1805 #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
1807 // get a random 64 bit number
1808 #define RAND_LL() MAKE_LL(rand(), rand(), rand(), rand())
1810 static const long testLongs
[] =
1821 #if wxUSE_LONGLONG_WX
1822 inline bool operator==(const wxLongLongWx
& a
, const wxLongLongNative
& b
)
1823 { return a
.GetHi() == b
.GetHi() && a
.GetLo() == b
.GetLo(); }
1824 inline bool operator==(const wxLongLongNative
& a
, const wxLongLongWx
& b
)
1825 { return a
.GetHi() == b
.GetHi() && a
.GetLo() == b
.GetLo(); }
1826 #endif // wxUSE_LONGLONG_WX
1828 static void TestSpeed()
1830 static const long max
= 100000000;
1837 for ( n
= 0; n
< max
; n
++ )
1842 printf("Summing longs took %ld milliseconds.\n", sw
.Time());
1845 #if wxUSE_LONGLONG_NATIVE
1850 for ( n
= 0; n
< max
; n
++ )
1855 printf("Summing wxLongLong_t took %ld milliseconds.\n", sw
.Time());
1857 #endif // wxUSE_LONGLONG_NATIVE
1863 for ( n
= 0; n
< max
; n
++ )
1868 printf("Summing wxLongLongs took %ld milliseconds.\n", sw
.Time());
1872 static void TestLongLongConversion()
1874 puts("*** Testing wxLongLong conversions ***\n");
1878 for ( size_t n
= 0; n
< 100000; n
++ )
1882 #if wxUSE_LONGLONG_NATIVE
1883 wxLongLongNative
b(a
.GetHi(), a
.GetLo());
1885 wxASSERT_MSG( a
== b
, "conversions failure" );
1887 puts("Can't do it without native long long type, test skipped.");
1890 #endif // wxUSE_LONGLONG_NATIVE
1892 if ( !(nTested
% 1000) )
1904 static void TestMultiplication()
1906 puts("*** Testing wxLongLong multiplication ***\n");
1910 for ( size_t n
= 0; n
< 100000; n
++ )
1915 #if wxUSE_LONGLONG_NATIVE
1916 wxLongLongNative
aa(a
.GetHi(), a
.GetLo());
1917 wxLongLongNative
bb(b
.GetHi(), b
.GetLo());
1919 wxASSERT_MSG( a
*b
== aa
*bb
, "multiplication failure" );
1920 #else // !wxUSE_LONGLONG_NATIVE
1921 puts("Can't do it without native long long type, test skipped.");
1924 #endif // wxUSE_LONGLONG_NATIVE
1926 if ( !(nTested
% 1000) )
1938 static void TestDivision()
1940 puts("*** Testing wxLongLong division ***\n");
1944 for ( size_t n
= 0; n
< 100000; n
++ )
1946 // get a random wxLongLong (shifting by 12 the MSB ensures that the
1947 // multiplication will not overflow)
1948 wxLongLong ll
= MAKE_LL((rand() >> 12), rand(), rand(), rand());
1950 // get a random long (not wxLongLong for now) to divide it with
1955 #if wxUSE_LONGLONG_NATIVE
1956 wxLongLongNative
m(ll
.GetHi(), ll
.GetLo());
1958 wxLongLongNative p
= m
/ l
, s
= m
% l
;
1959 wxASSERT_MSG( q
== p
&& r
== s
, "division failure" );
1960 #else // !wxUSE_LONGLONG_NATIVE
1961 // verify the result
1962 wxASSERT_MSG( ll
== q
*l
+ r
, "division failure" );
1963 #endif // wxUSE_LONGLONG_NATIVE
1965 if ( !(nTested
% 1000) )
1977 static void TestAddition()
1979 puts("*** Testing wxLongLong addition ***\n");
1983 for ( size_t n
= 0; n
< 100000; n
++ )
1989 #if wxUSE_LONGLONG_NATIVE
1990 wxASSERT_MSG( c
== wxLongLongNative(a
.GetHi(), a
.GetLo()) +
1991 wxLongLongNative(b
.GetHi(), b
.GetLo()),
1992 "addition failure" );
1993 #else // !wxUSE_LONGLONG_NATIVE
1994 wxASSERT_MSG( c
- b
== a
, "addition failure" );
1995 #endif // wxUSE_LONGLONG_NATIVE
1997 if ( !(nTested
% 1000) )
2009 static void TestBitOperations()
2011 puts("*** Testing wxLongLong bit operation ***\n");
2015 for ( size_t n
= 0; n
< 100000; n
++ )
2019 #if wxUSE_LONGLONG_NATIVE
2020 for ( size_t n
= 0; n
< 33; n
++ )
2023 #else // !wxUSE_LONGLONG_NATIVE
2024 puts("Can't do it without native long long type, test skipped.");
2027 #endif // wxUSE_LONGLONG_NATIVE
2029 if ( !(nTested
% 1000) )
2041 static void TestLongLongComparison()
2043 #if wxUSE_LONGLONG_WX
2044 puts("*** Testing wxLongLong comparison ***\n");
2046 static const long ls
[2] =
2052 wxLongLongWx lls
[2];
2056 for ( size_t n
= 0; n
< WXSIZEOF(testLongs
); n
++ )
2060 for ( size_t m
= 0; m
< WXSIZEOF(lls
); m
++ )
2062 res
= lls
[m
] > testLongs
[n
];
2063 printf("0x%lx > 0x%lx is %s (%s)\n",
2064 ls
[m
], testLongs
[n
], res
? "true" : "false",
2065 res
== (ls
[m
] > testLongs
[n
]) ? "ok" : "ERROR");
2067 res
= lls
[m
] < testLongs
[n
];
2068 printf("0x%lx < 0x%lx is %s (%s)\n",
2069 ls
[m
], testLongs
[n
], res
? "true" : "false",
2070 res
== (ls
[m
] < testLongs
[n
]) ? "ok" : "ERROR");
2072 res
= lls
[m
] == testLongs
[n
];
2073 printf("0x%lx == 0x%lx is %s (%s)\n",
2074 ls
[m
], testLongs
[n
], res
? "true" : "false",
2075 res
== (ls
[m
] == testLongs
[n
]) ? "ok" : "ERROR");
2078 #endif // wxUSE_LONGLONG_WX
2081 static void TestLongLongPrint()
2083 wxPuts(_T("*** Testing wxLongLong printing ***\n"));
2085 for ( size_t n
= 0; n
< WXSIZEOF(testLongs
); n
++ )
2087 wxLongLong ll
= testLongs
[n
];
2088 wxPrintf(_T("%ld == %s\n"), testLongs
[n
], ll
.ToString().c_str());
2091 wxLongLong
ll(0x12345678, 0x87654321);
2092 wxPrintf(_T("0x1234567887654321 = %s\n"), ll
.ToString().c_str());
2095 wxPrintf(_T("-0x1234567887654321 = %s\n"), ll
.ToString().c_str());
2101 #endif // TEST_LONGLONG
2103 // ----------------------------------------------------------------------------
2105 // ----------------------------------------------------------------------------
2107 #ifdef TEST_PATHLIST
2109 static void TestPathList()
2111 puts("*** Testing wxPathList ***\n");
2113 wxPathList pathlist
;
2114 pathlist
.AddEnvList("PATH");
2115 wxString path
= pathlist
.FindValidPath("ls");
2118 printf("ERROR: command not found in the path.\n");
2122 printf("Command found in the path as '%s'.\n", path
.c_str());
2126 #endif // TEST_PATHLIST
2128 // ----------------------------------------------------------------------------
2129 // regular expressions
2130 // ----------------------------------------------------------------------------
2134 #include "wx/regex.h"
2136 static void TestRegExCompile()
2138 wxPuts(_T("*** Testing RE compilation ***\n"));
2140 static struct RegExCompTestData
2142 const wxChar
*pattern
;
2144 } regExCompTestData
[] =
2146 { _T("foo"), TRUE
},
2147 { _T("foo("), FALSE
},
2148 { _T("foo(bar"), FALSE
},
2149 { _T("foo(bar)"), TRUE
},
2150 { _T("foo["), FALSE
},
2151 { _T("foo[bar"), FALSE
},
2152 { _T("foo[bar]"), TRUE
},
2153 { _T("foo{"), TRUE
},
2154 { _T("foo{1"), FALSE
},
2155 { _T("foo{bar"), TRUE
},
2156 { _T("foo{1}"), TRUE
},
2157 { _T("foo{1,2}"), TRUE
},
2158 { _T("foo{bar}"), TRUE
},
2159 { _T("foo*"), TRUE
},
2160 { _T("foo**"), FALSE
},
2161 { _T("foo+"), TRUE
},
2162 { _T("foo++"), FALSE
},
2163 { _T("foo?"), TRUE
},
2164 { _T("foo??"), FALSE
},
2165 { _T("foo?+"), FALSE
},
2169 for ( size_t n
= 0; n
< WXSIZEOF(regExCompTestData
); n
++ )
2171 const RegExCompTestData
& data
= regExCompTestData
[n
];
2172 bool ok
= re
.Compile(data
.pattern
);
2174 wxPrintf(_T("'%s' is %sa valid RE (%s)\n"),
2176 ok
? _T("") : _T("not "),
2177 ok
== data
.correct
? _T("ok") : _T("ERROR"));
2181 static void TestRegExMatch()
2183 wxPuts(_T("*** Testing RE matching ***\n"));
2185 static struct RegExMatchTestData
2187 const wxChar
*pattern
;
2190 } regExMatchTestData
[] =
2192 { _T("foo"), _T("bar"), FALSE
},
2193 { _T("foo"), _T("foobar"), TRUE
},
2194 { _T("^foo"), _T("foobar"), TRUE
},
2195 { _T("^foo"), _T("barfoo"), FALSE
},
2196 { _T("bar$"), _T("barbar"), TRUE
},
2197 { _T("bar$"), _T("barbar "), FALSE
},
2200 for ( size_t n
= 0; n
< WXSIZEOF(regExMatchTestData
); n
++ )
2202 const RegExMatchTestData
& data
= regExMatchTestData
[n
];
2204 wxRegEx
re(data
.pattern
);
2205 bool ok
= re
.Matches(data
.text
);
2207 wxPrintf(_T("'%s' %s %s (%s)\n"),
2209 ok
? _T("matches") : _T("doesn't match"),
2211 ok
== data
.correct
? _T("ok") : _T("ERROR"));
2215 static void TestRegExSubmatch()
2217 wxPuts(_T("*** Testing RE subexpressions ***\n"));
2219 wxRegEx
re(_T("([[:alpha:]]+) ([[:alpha:]]+) ([[:digit:]]+).*([[:digit:]]+)$"));
2220 if ( !re
.IsValid() )
2222 wxPuts(_T("ERROR: compilation failed."));
2226 wxString text
= _T("Fri Jul 13 18:37:52 CEST 2001");
2228 if ( !re
.Matches(text
) )
2230 wxPuts(_T("ERROR: match expected."));
2234 wxPrintf(_T("Entire match: %s\n"), re
.GetMatch(text
).c_str());
2236 wxPrintf(_T("Date: %s/%s/%s, wday: %s\n"),
2237 re
.GetMatch(text
, 3).c_str(),
2238 re
.GetMatch(text
, 2).c_str(),
2239 re
.GetMatch(text
, 4).c_str(),
2240 re
.GetMatch(text
, 1).c_str());
2244 static void TestRegExReplacement()
2246 wxPuts(_T("*** Testing RE replacement ***"));
2248 static struct RegExReplTestData
2252 const wxChar
*result
;
2254 } regExReplTestData
[] =
2256 { _T("foo123"), _T("bar"), _T("bar"), 1 },
2257 { _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
2258 { _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
2259 { _T("123foo"), _T("bar"), _T("123foo"), 0 },
2260 { _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
2261 { _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
2262 { _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
2265 const wxChar
*pattern
= _T("([a-z]+)[^0-9]*([0-9]+)");
2266 wxRegEx
re(pattern
);
2268 wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern
);
2270 for ( size_t n
= 0; n
< WXSIZEOF(regExReplTestData
); n
++ )
2272 const RegExReplTestData
& data
= regExReplTestData
[n
];
2274 wxString text
= data
.text
;
2275 size_t nRepl
= re
.Replace(&text
, data
.repl
);
2277 wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
2278 data
.text
, data
.repl
,
2279 nRepl
, nRepl
== 1 ? _T("") : _T("es"),
2281 if ( text
== data
.result
&& nRepl
== data
.count
)
2287 wxPrintf(_T("ERROR: should be %u and '%s')\n"),
2288 data
.count
, data
.result
);
2293 static void TestRegExInteractive()
2295 wxPuts(_T("*** Testing RE interactively ***"));
2300 printf("\nEnter a pattern: ");
2301 if ( !fgets(pattern
, WXSIZEOF(pattern
), stdin
) )
2304 // kill the last '\n'
2305 pattern
[strlen(pattern
) - 1] = 0;
2308 if ( !re
.Compile(pattern
) )
2316 printf("Enter text to match: ");
2317 if ( !fgets(text
, WXSIZEOF(text
), stdin
) )
2320 // kill the last '\n'
2321 text
[strlen(text
) - 1] = 0;
2323 if ( !re
.Matches(text
) )
2325 printf("No match.\n");
2329 printf("Pattern matches at '%s'\n", re
.GetMatch(text
).c_str());
2332 for ( size_t n
= 1; ; n
++ )
2334 if ( !re
.GetMatch(&start
, &len
, n
) )
2339 printf("Subexpr %u matched '%s'\n",
2340 n
, wxString(text
+ start
, len
).c_str());
2347 #endif // TEST_REGEX
2349 // ----------------------------------------------------------------------------
2351 // ----------------------------------------------------------------------------
2357 static void TestDbOpen()
2365 // ----------------------------------------------------------------------------
2366 // registry and related stuff
2367 // ----------------------------------------------------------------------------
2369 // this is for MSW only
2372 #undef TEST_REGISTRY
2377 #include "wx/confbase.h"
2378 #include "wx/msw/regconf.h"
2380 static void TestRegConfWrite()
2382 wxRegConfig
regconf(_T("console"), _T("wxwindows"));
2383 regconf
.Write(_T("Hello"), wxString(_T("world")));
2386 #endif // TEST_REGCONF
2388 #ifdef TEST_REGISTRY
2390 #include "wx/msw/registry.h"
2392 // I chose this one because I liked its name, but it probably only exists under
2394 static const wxChar
*TESTKEY
=
2395 _T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
2397 static void TestRegistryRead()
2399 puts("*** testing registry reading ***");
2401 wxRegKey
key(TESTKEY
);
2402 printf("The test key name is '%s'.\n", key
.GetName().c_str());
2405 puts("ERROR: test key can't be opened, aborting test.");
2410 size_t nSubKeys
, nValues
;
2411 if ( key
.GetKeyInfo(&nSubKeys
, NULL
, &nValues
, NULL
) )
2413 printf("It has %u subkeys and %u values.\n", nSubKeys
, nValues
);
2416 printf("Enumerating values:\n");
2420 bool cont
= key
.GetFirstValue(value
, dummy
);
2423 printf("Value '%s': type ", value
.c_str());
2424 switch ( key
.GetValueType(value
) )
2426 case wxRegKey::Type_None
: printf("ERROR (none)"); break;
2427 case wxRegKey::Type_String
: printf("SZ"); break;
2428 case wxRegKey::Type_Expand_String
: printf("EXPAND_SZ"); break;
2429 case wxRegKey::Type_Binary
: printf("BINARY"); break;
2430 case wxRegKey::Type_Dword
: printf("DWORD"); break;
2431 case wxRegKey::Type_Multi_String
: printf("MULTI_SZ"); break;
2432 default: printf("other (unknown)"); break;
2435 printf(", value = ");
2436 if ( key
.IsNumericValue(value
) )
2439 key
.QueryValue(value
, &val
);
2445 key
.QueryValue(value
, val
);
2446 printf("'%s'", val
.c_str());
2448 key
.QueryRawValue(value
, val
);
2449 printf(" (raw value '%s')", val
.c_str());
2454 cont
= key
.GetNextValue(value
, dummy
);
2458 static void TestRegistryAssociation()
2461 The second call to deleteself genertaes an error message, with a
2462 messagebox saying .flo is crucial to system operation, while the .ddf
2463 call also fails, but with no error message
2468 key
.SetName("HKEY_CLASSES_ROOT\\.ddf" );
2470 key
= "ddxf_auto_file" ;
2471 key
.SetName("HKEY_CLASSES_ROOT\\.flo" );
2473 key
= "ddxf_auto_file" ;
2474 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
2477 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
2479 key
= "program \"%1\"" ;
2481 key
.SetName("HKEY_CLASSES_ROOT\\.ddf" );
2483 key
.SetName("HKEY_CLASSES_ROOT\\.flo" );
2485 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
2487 key
.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
2491 #endif // TEST_REGISTRY
2493 // ----------------------------------------------------------------------------
2495 // ----------------------------------------------------------------------------
2499 #include "wx/socket.h"
2500 #include "wx/protocol/protocol.h"
2501 #include "wx/protocol/http.h"
2503 static void TestSocketServer()
2505 puts("*** Testing wxSocketServer ***\n");
2507 static const int PORT
= 3000;
2512 wxSocketServer
*server
= new wxSocketServer(addr
);
2513 if ( !server
->Ok() )
2515 puts("ERROR: failed to bind");
2522 printf("Server: waiting for connection on port %d...\n", PORT
);
2524 wxSocketBase
*socket
= server
->Accept();
2527 puts("ERROR: wxSocketServer::Accept() failed.");
2531 puts("Server: got a client.");
2533 server
->SetTimeout(60); // 1 min
2535 while ( socket
->IsConnected() )
2541 if ( socket
->Read(&ch
, sizeof(ch
)).Error() )
2543 // don't log error if the client just close the connection
2544 if ( socket
->IsConnected() )
2546 puts("ERROR: in wxSocket::Read.");
2566 printf("Server: got '%s'.\n", s
.c_str());
2567 if ( s
== _T("bye") )
2574 socket
->Write(s
.MakeUpper().c_str(), s
.length());
2575 socket
->Write("\r\n", 2);
2576 printf("Server: wrote '%s'.\n", s
.c_str());
2579 puts("Server: lost a client.");
2584 // same as "delete server" but is consistent with GUI programs
2588 static void TestSocketClient()
2590 puts("*** Testing wxSocketClient ***\n");
2592 static const char *hostname
= "www.wxwindows.org";
2595 addr
.Hostname(hostname
);
2598 printf("--- Attempting to connect to %s:80...\n", hostname
);
2600 wxSocketClient client
;
2601 if ( !client
.Connect(addr
) )
2603 printf("ERROR: failed to connect to %s\n", hostname
);
2607 printf("--- Connected to %s:%u...\n",
2608 addr
.Hostname().c_str(), addr
.Service());
2612 // could use simply "GET" here I suppose
2614 wxString::Format("GET http://%s/\r\n", hostname
);
2615 client
.Write(cmdGet
, cmdGet
.length());
2616 printf("--- Sent command '%s' to the server\n",
2617 MakePrintable(cmdGet
).c_str());
2618 client
.Read(buf
, WXSIZEOF(buf
));
2619 printf("--- Server replied:\n%s", buf
);
2623 #endif // TEST_SOCKETS
2625 // ----------------------------------------------------------------------------
2627 // ----------------------------------------------------------------------------
2631 #include "wx/protocol/ftp.h"
2635 #define FTP_ANONYMOUS
2637 #ifdef FTP_ANONYMOUS
2638 static const char *directory
= "/pub";
2639 static const char *filename
= "welcome.msg";
2641 static const char *directory
= "/etc";
2642 static const char *filename
= "issue";
2645 static bool TestFtpConnect()
2647 puts("*** Testing FTP connect ***");
2649 #ifdef FTP_ANONYMOUS
2650 static const char *hostname
= "ftp.wxwindows.org";
2652 printf("--- Attempting to connect to %s:21 anonymously...\n", hostname
);
2653 #else // !FTP_ANONYMOUS
2654 static const char *hostname
= "localhost";
2657 fgets(user
, WXSIZEOF(user
), stdin
);
2658 user
[strlen(user
) - 1] = '\0'; // chop off '\n'
2662 printf("Password for %s: ", password
);
2663 fgets(password
, WXSIZEOF(password
), stdin
);
2664 password
[strlen(password
) - 1] = '\0'; // chop off '\n'
2665 ftp
.SetPassword(password
);
2667 printf("--- Attempting to connect to %s:21 as %s...\n", hostname
, user
);
2668 #endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
2670 if ( !ftp
.Connect(hostname
) )
2672 printf("ERROR: failed to connect to %s\n", hostname
);
2678 printf("--- Connected to %s, current directory is '%s'\n",
2679 hostname
, ftp
.Pwd().c_str());
2685 // test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
2686 static void TestFtpWuFtpd()
2689 static const char *hostname
= "ftp.eudora.com";
2690 if ( !ftp
.Connect(hostname
) )
2692 printf("ERROR: failed to connect to %s\n", hostname
);
2696 static const char *filename
= "eudora/pubs/draft-gellens-submit-09.txt";
2697 wxInputStream
*in
= ftp
.GetInputStream(filename
);
2700 printf("ERROR: couldn't get input stream for %s\n", filename
);
2704 size_t size
= in
->StreamSize();
2705 printf("Reading file %s (%u bytes)...", filename
, size
);
2707 char *data
= new char[size
];
2708 if ( !in
->Read(data
, size
) )
2710 puts("ERROR: read error");
2714 printf("Successfully retrieved the file.\n");
2723 static void TestFtpList()
2725 puts("*** Testing wxFTP file listing ***\n");
2728 if ( !ftp
.ChDir(directory
) )
2730 printf("ERROR: failed to cd to %s\n", directory
);
2733 printf("Current directory is '%s'\n", ftp
.Pwd().c_str());
2735 // test NLIST and LIST
2736 wxArrayString files
;
2737 if ( !ftp
.GetFilesList(files
) )
2739 puts("ERROR: failed to get NLIST of files");
2743 printf("Brief list of files under '%s':\n", ftp
.Pwd().c_str());
2744 size_t count
= files
.GetCount();
2745 for ( size_t n
= 0; n
< count
; n
++ )
2747 printf("\t%s\n", files
[n
].c_str());
2749 puts("End of the file list");
2752 if ( !ftp
.GetDirList(files
) )
2754 puts("ERROR: failed to get LIST of files");
2758 printf("Detailed list of files under '%s':\n", ftp
.Pwd().c_str());
2759 size_t count
= files
.GetCount();
2760 for ( size_t n
= 0; n
< count
; n
++ )
2762 printf("\t%s\n", files
[n
].c_str());
2764 puts("End of the file list");
2767 if ( !ftp
.ChDir(_T("..")) )
2769 puts("ERROR: failed to cd to ..");
2772 printf("Current directory is '%s'\n", ftp
.Pwd().c_str());
2775 static void TestFtpDownload()
2777 puts("*** Testing wxFTP download ***\n");
2780 wxInputStream
*in
= ftp
.GetInputStream(filename
);
2783 printf("ERROR: couldn't get input stream for %s\n", filename
);
2787 size_t size
= in
->StreamSize();
2788 printf("Reading file %s (%u bytes)...", filename
, size
);
2791 char *data
= new char[size
];
2792 if ( !in
->Read(data
, size
) )
2794 puts("ERROR: read error");
2798 printf("\nContents of %s:\n%s\n", filename
, data
);
2806 static void TestFtpFileSize()
2808 puts("*** Testing FTP SIZE command ***");
2810 if ( !ftp
.ChDir(directory
) )
2812 printf("ERROR: failed to cd to %s\n", directory
);
2815 printf("Current directory is '%s'\n", ftp
.Pwd().c_str());
2817 if ( ftp
.FileExists(filename
) )
2819 int size
= ftp
.GetFileSize(filename
);
2821 printf("ERROR: couldn't get size of '%s'\n", filename
);
2823 printf("Size of '%s' is %d bytes.\n", filename
, size
);
2827 printf("ERROR: '%s' doesn't exist\n", filename
);
2831 static void TestFtpMisc()
2833 puts("*** Testing miscellaneous wxFTP functions ***");
2835 if ( ftp
.SendCommand("STAT") != '2' )
2837 puts("ERROR: STAT failed");
2841 printf("STAT returned:\n\n%s\n", ftp
.GetLastResult().c_str());
2844 if ( ftp
.SendCommand("HELP SITE") != '2' )
2846 puts("ERROR: HELP SITE failed");
2850 printf("The list of site-specific commands:\n\n%s\n",
2851 ftp
.GetLastResult().c_str());
2855 static void TestFtpInteractive()
2857 puts("\n*** Interactive wxFTP test ***");
2863 printf("Enter FTP command: ");
2864 if ( !fgets(buf
, WXSIZEOF(buf
), stdin
) )
2867 // kill the last '\n'
2868 buf
[strlen(buf
) - 1] = 0;
2870 // special handling of LIST and NLST as they require data connection
2871 wxString
start(buf
, 4);
2873 if ( start
== "LIST" || start
== "NLST" )
2876 if ( strlen(buf
) > 4 )
2879 wxArrayString files
;
2880 if ( !ftp
.GetList(files
, wildcard
, start
== "LIST") )
2882 printf("ERROR: failed to get %s of files\n", start
.c_str());
2886 printf("--- %s of '%s' under '%s':\n",
2887 start
.c_str(), wildcard
.c_str(), ftp
.Pwd().c_str());
2888 size_t count
= files
.GetCount();
2889 for ( size_t n
= 0; n
< count
; n
++ )
2891 printf("\t%s\n", files
[n
].c_str());
2893 puts("--- End of the file list");
2898 char ch
= ftp
.SendCommand(buf
);
2899 printf("Command %s", ch
? "succeeded" : "failed");
2902 printf(" (return code %c)", ch
);
2905 printf(", server reply:\n%s\n\n", ftp
.GetLastResult().c_str());
2909 puts("\n*** done ***");
2912 static void TestFtpUpload()
2914 puts("*** Testing wxFTP uploading ***\n");
2917 static const char *file1
= "test1";
2918 static const char *file2
= "test2";
2919 wxOutputStream
*out
= ftp
.GetOutputStream(file1
);
2922 printf("--- Uploading to %s ---\n", file1
);
2923 out
->Write("First hello", 11);
2927 // send a command to check the remote file
2928 if ( ftp
.SendCommand(wxString("STAT ") + file1
) != '2' )
2930 printf("ERROR: STAT %s failed\n", file1
);
2934 printf("STAT %s returned:\n\n%s\n",
2935 file1
, ftp
.GetLastResult().c_str());
2938 out
= ftp
.GetOutputStream(file2
);
2941 printf("--- Uploading to %s ---\n", file1
);
2942 out
->Write("Second hello", 12);
2949 // ----------------------------------------------------------------------------
2951 // ----------------------------------------------------------------------------
2955 #include "wx/wfstream.h"
2956 #include "wx/mstream.h"
2958 static void TestFileStream()
2960 puts("*** Testing wxFileInputStream ***");
2962 static const wxChar
*filename
= _T("testdata.fs");
2964 wxFileOutputStream
fsOut(filename
);
2965 fsOut
.Write("foo", 3);
2968 wxFileInputStream
fsIn(filename
);
2969 printf("File stream size: %u\n", fsIn
.GetSize());
2970 while ( !fsIn
.Eof() )
2972 putchar(fsIn
.GetC());
2975 if ( !wxRemoveFile(filename
) )
2977 printf("ERROR: failed to remove the file '%s'.\n", filename
);
2980 puts("\n*** wxFileInputStream test done ***");
2983 static void TestMemoryStream()
2985 puts("*** Testing wxMemoryInputStream ***");
2988 wxStrncpy(buf
, _T("Hello, stream!"), WXSIZEOF(buf
));
2990 wxMemoryInputStream
memInpStream(buf
, wxStrlen(buf
));
2991 printf(_T("Memory stream size: %u\n"), memInpStream
.GetSize());
2992 while ( !memInpStream
.Eof() )
2994 putchar(memInpStream
.GetC());
2997 puts("\n*** wxMemoryInputStream test done ***");
3000 #endif // TEST_STREAMS
3002 // ----------------------------------------------------------------------------
3004 // ----------------------------------------------------------------------------
3008 #include "wx/timer.h"
3009 #include "wx/utils.h"
3011 static void TestStopWatch()
3013 puts("*** Testing wxStopWatch ***\n");
3016 printf("Sleeping 3 seconds...");
3018 printf("\telapsed time: %ldms\n", sw
.Time());
3021 printf("Sleeping 2 more seconds...");
3023 printf("\telapsed time: %ldms\n", sw
.Time());
3026 printf("And 3 more seconds...");
3028 printf("\telapsed time: %ldms\n", sw
.Time());
3031 puts("\nChecking for 'backwards clock' bug...");
3032 for ( size_t n
= 0; n
< 70; n
++ )
3036 for ( size_t m
= 0; m
< 100000; m
++ )
3038 if ( sw
.Time() < 0 || sw2
.Time() < 0 )
3040 puts("\ntime is negative - ERROR!");
3050 #endif // TEST_TIMER
3052 // ----------------------------------------------------------------------------
3054 // ----------------------------------------------------------------------------
3058 #include "wx/vcard.h"
3060 static void DumpVObject(size_t level
, const wxVCardObject
& vcard
)
3063 wxVCardObject
*vcObj
= vcard
.GetFirstProp(&cookie
);
3067 wxString(_T('\t'), level
).c_str(),
3068 vcObj
->GetName().c_str());
3071 switch ( vcObj
->GetType() )
3073 case wxVCardObject::String
:
3074 case wxVCardObject::UString
:
3077 vcObj
->GetValue(&val
);
3078 value
<< _T('"') << val
<< _T('"');
3082 case wxVCardObject::Int
:
3085 vcObj
->GetValue(&i
);
3086 value
.Printf(_T("%u"), i
);
3090 case wxVCardObject::Long
:
3093 vcObj
->GetValue(&l
);
3094 value
.Printf(_T("%lu"), l
);
3098 case wxVCardObject::None
:
3101 case wxVCardObject::Object
:
3102 value
= _T("<node>");
3106 value
= _T("<unknown value type>");
3110 printf(" = %s", value
.c_str());
3113 DumpVObject(level
+ 1, *vcObj
);
3116 vcObj
= vcard
.GetNextProp(&cookie
);
3120 static void DumpVCardAddresses(const wxVCard
& vcard
)
3122 puts("\nShowing all addresses from vCard:\n");
3126 wxVCardAddress
*addr
= vcard
.GetFirstAddress(&cookie
);
3130 int flags
= addr
->GetFlags();
3131 if ( flags
& wxVCardAddress::Domestic
)
3133 flagsStr
<< _T("domestic ");
3135 if ( flags
& wxVCardAddress::Intl
)
3137 flagsStr
<< _T("international ");
3139 if ( flags
& wxVCardAddress::Postal
)
3141 flagsStr
<< _T("postal ");
3143 if ( flags
& wxVCardAddress::Parcel
)
3145 flagsStr
<< _T("parcel ");
3147 if ( flags
& wxVCardAddress::Home
)
3149 flagsStr
<< _T("home ");
3151 if ( flags
& wxVCardAddress::Work
)
3153 flagsStr
<< _T("work ");
3156 printf("Address %u:\n"
3158 "\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
3161 addr
->GetPostOffice().c_str(),
3162 addr
->GetExtAddress().c_str(),
3163 addr
->GetStreet().c_str(),
3164 addr
->GetLocality().c_str(),
3165 addr
->GetRegion().c_str(),
3166 addr
->GetPostalCode().c_str(),
3167 addr
->GetCountry().c_str()
3171 addr
= vcard
.GetNextAddress(&cookie
);
3175 static void DumpVCardPhoneNumbers(const wxVCard
& vcard
)
3177 puts("\nShowing all phone numbers from vCard:\n");
3181 wxVCardPhoneNumber
*phone
= vcard
.GetFirstPhoneNumber(&cookie
);
3185 int flags
= phone
->GetFlags();
3186 if ( flags
& wxVCardPhoneNumber::Voice
)
3188 flagsStr
<< _T("voice ");
3190 if ( flags
& wxVCardPhoneNumber::Fax
)
3192 flagsStr
<< _T("fax ");
3194 if ( flags
& wxVCardPhoneNumber::Cellular
)
3196 flagsStr
<< _T("cellular ");
3198 if ( flags
& wxVCardPhoneNumber::Modem
)
3200 flagsStr
<< _T("modem ");
3202 if ( flags
& wxVCardPhoneNumber::Home
)
3204 flagsStr
<< _T("home ");
3206 if ( flags
& wxVCardPhoneNumber::Work
)
3208 flagsStr
<< _T("work ");
3211 printf("Phone number %u:\n"
3216 phone
->GetNumber().c_str()
3220 phone
= vcard
.GetNextPhoneNumber(&cookie
);
3224 static void TestVCardRead()
3226 puts("*** Testing wxVCard reading ***\n");
3228 wxVCard
vcard(_T("vcard.vcf"));
3229 if ( !vcard
.IsOk() )
3231 puts("ERROR: couldn't load vCard.");
3235 // read individual vCard properties
3236 wxVCardObject
*vcObj
= vcard
.GetProperty("FN");
3240 vcObj
->GetValue(&value
);
3245 value
= _T("<none>");
3248 printf("Full name retrieved directly: %s\n", value
.c_str());
3251 if ( !vcard
.GetFullName(&value
) )
3253 value
= _T("<none>");
3256 printf("Full name from wxVCard API: %s\n", value
.c_str());
3258 // now show how to deal with multiply occuring properties
3259 DumpVCardAddresses(vcard
);
3260 DumpVCardPhoneNumbers(vcard
);
3262 // and finally show all
3263 puts("\nNow dumping the entire vCard:\n"
3264 "-----------------------------\n");
3266 DumpVObject(0, vcard
);
3270 static void TestVCardWrite()
3272 puts("*** Testing wxVCard writing ***\n");
3275 if ( !vcard
.IsOk() )
3277 puts("ERROR: couldn't create vCard.");
3282 vcard
.SetName("Zeitlin", "Vadim");
3283 vcard
.SetFullName("Vadim Zeitlin");
3284 vcard
.SetOrganization("wxWindows", "R&D");
3286 // just dump the vCard back
3287 puts("Entire vCard follows:\n");
3288 puts(vcard
.Write());
3292 #endif // TEST_VCARD
3294 // ----------------------------------------------------------------------------
3295 // wide char (Unicode) support
3296 // ----------------------------------------------------------------------------
3300 #include "wx/strconv.h"
3301 #include "wx/fontenc.h"
3302 #include "wx/encconv.h"
3303 #include "wx/buffer.h"
3305 static void TestUtf8()
3307 puts("*** Testing UTF8 support ***\n");
3309 static const char textInUtf8
[] =
3311 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
3312 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
3313 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
3314 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
3315 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
3316 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
3317 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
3322 if ( wxConvUTF8
.MB2WC(wbuf
, textInUtf8
, WXSIZEOF(textInUtf8
)) <= 0 )
3324 puts("ERROR: UTF-8 decoding failed.");
3328 // using wxEncodingConverter
3330 wxEncodingConverter ec
;
3331 ec
.Init(wxFONTENCODING_UNICODE
, wxFONTENCODING_KOI8
);
3332 ec
.Convert(wbuf
, buf
);
3333 #else // using wxCSConv
3334 wxCSConv
conv(_T("koi8-r"));
3335 if ( conv
.WC2MB(buf
, wbuf
, 0 /* not needed wcslen(wbuf) */) <= 0 )
3337 puts("ERROR: conversion to KOI8-R failed.");
3342 printf("The resulting string (in koi8-r): %s\n", buf
);
3346 #endif // TEST_WCHAR
3348 // ----------------------------------------------------------------------------
3350 // ----------------------------------------------------------------------------
3354 #include "wx/filesys.h"
3355 #include "wx/fs_zip.h"
3356 #include "wx/zipstrm.h"
3358 static const wxChar
*TESTFILE_ZIP
= _T("testdata.zip");
3360 static void TestZipStreamRead()
3362 puts("*** Testing ZIP reading ***\n");
3364 static const wxChar
*filename
= _T("foo");
3365 wxZipInputStream
istr(TESTFILE_ZIP
, filename
);
3366 printf("Archive size: %u\n", istr
.GetSize());
3368 printf("Dumping the file '%s':\n", filename
);
3369 while ( !istr
.Eof() )
3371 putchar(istr
.GetC());
3375 puts("\n----- done ------");
3378 static void DumpZipDirectory(wxFileSystem
& fs
,
3379 const wxString
& dir
,
3380 const wxString
& indent
)
3382 wxString prefix
= wxString::Format(_T("%s#zip:%s"),
3383 TESTFILE_ZIP
, dir
.c_str());
3384 wxString wildcard
= prefix
+ _T("/*");
3386 wxString dirname
= fs
.FindFirst(wildcard
, wxDIR
);
3387 while ( !dirname
.empty() )
3389 if ( !dirname
.StartsWith(prefix
+ _T('/'), &dirname
) )
3391 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3396 wxPrintf(_T("%s%s\n"), indent
.c_str(), dirname
.c_str());
3398 DumpZipDirectory(fs
, dirname
,
3399 indent
+ wxString(_T(' '), 4));
3401 dirname
= fs
.FindNext();
3404 wxString filename
= fs
.FindFirst(wildcard
, wxFILE
);
3405 while ( !filename
.empty() )
3407 if ( !filename
.StartsWith(prefix
, &filename
) )
3409 wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
3414 wxPrintf(_T("%s%s\n"), indent
.c_str(), filename
.c_str());
3416 filename
= fs
.FindNext();
3420 static void TestZipFileSystem()
3422 puts("*** Testing ZIP file system ***\n");
3424 wxFileSystem::AddHandler(new wxZipFSHandler
);
3426 wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP
);
3428 DumpZipDirectory(fs
, _T(""), wxString(_T(' '), 4));
3433 // ----------------------------------------------------------------------------
3435 // ----------------------------------------------------------------------------
3439 #include "wx/zstream.h"
3440 #include "wx/wfstream.h"
3442 static const wxChar
*FILENAME_GZ
= _T("test.gz");
3443 static const char *TEST_DATA
= "hello and hello again";
3445 static void TestZlibStreamWrite()
3447 puts("*** Testing Zlib stream reading ***\n");
3449 wxFileOutputStream
fileOutStream(FILENAME_GZ
);
3450 wxZlibOutputStream
ostr(fileOutStream
, 0);
3451 printf("Compressing the test string... ");
3452 ostr
.Write(TEST_DATA
, sizeof(TEST_DATA
));
3455 puts("(ERROR: failed)");
3462 puts("\n----- done ------");
3465 static void TestZlibStreamRead()
3467 puts("*** Testing Zlib stream reading ***\n");
3469 wxFileInputStream
fileInStream(FILENAME_GZ
);
3470 wxZlibInputStream
istr(fileInStream
);
3471 printf("Archive size: %u\n", istr
.GetSize());
3473 puts("Dumping the file:");
3474 while ( !istr
.Eof() )
3476 putchar(istr
.GetC());
3480 puts("\n----- done ------");
3485 // ----------------------------------------------------------------------------
3487 // ----------------------------------------------------------------------------
3489 #ifdef TEST_DATETIME
3493 #include "wx/date.h"
3494 #include "wx/datetime.h"
3499 wxDateTime::wxDateTime_t day
;
3500 wxDateTime::Month month
;
3502 wxDateTime::wxDateTime_t hour
, min
, sec
;
3504 wxDateTime::WeekDay wday
;
3505 time_t gmticks
, ticks
;
3507 void Init(const wxDateTime::Tm
& tm
)
3516 gmticks
= ticks
= -1;
3519 wxDateTime
DT() const
3520 { return wxDateTime(day
, month
, year
, hour
, min
, sec
); }
3522 bool SameDay(const wxDateTime::Tm
& tm
) const
3524 return day
== tm
.mday
&& month
== tm
.mon
&& year
== tm
.year
;
3527 wxString
Format() const
3530 s
.Printf("%02d:%02d:%02d %10s %02d, %4d%s",
3532 wxDateTime::GetMonthName(month
).c_str(),
3534 abs(wxDateTime::ConvertYearToBC(year
)),
3535 year
> 0 ? "AD" : "BC");
3539 wxString
FormatDate() const
3542 s
.Printf("%02d-%s-%4d%s",
3544 wxDateTime::GetMonthName(month
, wxDateTime::Name_Abbr
).c_str(),
3545 abs(wxDateTime::ConvertYearToBC(year
)),
3546 year
> 0 ? "AD" : "BC");
3551 static const Date testDates
[] =
3553 { 1, wxDateTime::Jan
, 1970, 00, 00, 00, 2440587.5, wxDateTime::Thu
, 0, -3600 },
3554 { 21, wxDateTime::Jan
, 2222, 00, 00, 00, 2532648.5, wxDateTime::Mon
, -1, -1 },
3555 { 29, wxDateTime::May
, 1976, 12, 00, 00, 2442928.0, wxDateTime::Sat
, 202219200, 202212000 },
3556 { 29, wxDateTime::Feb
, 1976, 00, 00, 00, 2442837.5, wxDateTime::Sun
, 194400000, 194396400 },
3557 { 1, wxDateTime::Jan
, 1900, 12, 00, 00, 2415021.0, wxDateTime::Mon
, -1, -1 },
3558 { 1, wxDateTime::Jan
, 1900, 00, 00, 00, 2415020.5, wxDateTime::Mon
, -1, -1 },
3559 { 15, wxDateTime::Oct
, 1582, 00, 00, 00, 2299160.5, wxDateTime::Fri
, -1, -1 },
3560 { 4, wxDateTime::Oct
, 1582, 00, 00, 00, 2299149.5, wxDateTime::Mon
, -1, -1 },
3561 { 1, wxDateTime::Mar
, 1, 00, 00, 00, 1721484.5, wxDateTime::Thu
, -1, -1 },
3562 { 1, wxDateTime::Jan
, 1, 00, 00, 00, 1721425.5, wxDateTime::Mon
, -1, -1 },
3563 { 31, wxDateTime::Dec
, 0, 00, 00, 00, 1721424.5, wxDateTime::Sun
, -1, -1 },
3564 { 1, wxDateTime::Jan
, 0, 00, 00, 00, 1721059.5, wxDateTime::Sat
, -1, -1 },
3565 { 12, wxDateTime::Aug
, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri
, -1, -1 },
3566 { 12, wxDateTime::Aug
, -4000, 00, 00, 00, 260313.5, wxDateTime::Sat
, -1, -1 },
3567 { 24, wxDateTime::Nov
, -4713, 00, 00, 00, -0.5, wxDateTime::Mon
, -1, -1 },
3570 // this test miscellaneous static wxDateTime functions
3571 static void TestTimeStatic()
3573 puts("\n*** wxDateTime static methods test ***");
3575 // some info about the current date
3576 int year
= wxDateTime::GetCurrentYear();
3577 printf("Current year %d is %sa leap one and has %d days.\n",
3579 wxDateTime::IsLeapYear(year
) ? "" : "not ",
3580 wxDateTime::GetNumberOfDays(year
));
3582 wxDateTime::Month month
= wxDateTime::GetCurrentMonth();
3583 printf("Current month is '%s' ('%s') and it has %d days\n",
3584 wxDateTime::GetMonthName(month
, wxDateTime::Name_Abbr
).c_str(),
3585 wxDateTime::GetMonthName(month
).c_str(),
3586 wxDateTime::GetNumberOfDays(month
));
3589 static const size_t nYears
= 5;
3590 static const size_t years
[2][nYears
] =
3592 // first line: the years to test
3593 { 1990, 1976, 2000, 2030, 1984, },
3595 // second line: TRUE if leap, FALSE otherwise
3596 { FALSE
, TRUE
, TRUE
, FALSE
, TRUE
}
3599 for ( size_t n
= 0; n
< nYears
; n
++ )
3601 int year
= years
[0][n
];
3602 bool should
= years
[1][n
] != 0,
3603 is
= wxDateTime::IsLeapYear(year
);
3605 printf("Year %d is %sa leap year (%s)\n",
3608 should
== is
? "ok" : "ERROR");
3610 wxASSERT( should
== wxDateTime::IsLeapYear(year
) );
3614 // test constructing wxDateTime objects
3615 static void TestTimeSet()
3617 puts("\n*** wxDateTime construction test ***");
3619 for ( size_t n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3621 const Date
& d1
= testDates
[n
];
3622 wxDateTime dt
= d1
.DT();
3625 d2
.Init(dt
.GetTm());
3627 wxString s1
= d1
.Format(),
3630 printf("Date: %s == %s (%s)\n",
3631 s1
.c_str(), s2
.c_str(),
3632 s1
== s2
? "ok" : "ERROR");
3636 // test time zones stuff
3637 static void TestTimeZones()
3639 puts("\n*** wxDateTime timezone test ***");
3641 wxDateTime now
= wxDateTime::Now();
3643 printf("Current GMT time:\t%s\n", now
.Format("%c", wxDateTime::GMT0
).c_str());
3644 printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::GMT0
).c_str());
3645 printf("Unix epoch (EST):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::EST
).c_str());
3646 printf("Current time in Paris:\t%s\n", now
.Format("%c", wxDateTime::CET
).c_str());
3647 printf(" Moscow:\t%s\n", now
.Format("%c", wxDateTime::MSK
).c_str());
3648 printf(" New York:\t%s\n", now
.Format("%c", wxDateTime::EST
).c_str());
3650 wxDateTime::Tm tm
= now
.GetTm();
3651 if ( wxDateTime(tm
) != now
)
3653 printf("ERROR: got %s instead of %s\n",
3654 wxDateTime(tm
).Format().c_str(), now
.Format().c_str());
3658 // test some minimal support for the dates outside the standard range
3659 static void TestTimeRange()
3661 puts("\n*** wxDateTime out-of-standard-range dates test ***");
3663 static const char *fmt
= "%d-%b-%Y %H:%M:%S";
3665 printf("Unix epoch:\t%s\n",
3666 wxDateTime(2440587.5).Format(fmt
).c_str());
3667 printf("Feb 29, 0: \t%s\n",
3668 wxDateTime(29, wxDateTime::Feb
, 0).Format(fmt
).c_str());
3669 printf("JDN 0: \t%s\n",
3670 wxDateTime(0.0).Format(fmt
).c_str());
3671 printf("Jan 1, 1AD:\t%s\n",
3672 wxDateTime(1, wxDateTime::Jan
, 1).Format(fmt
).c_str());
3673 printf("May 29, 2099:\t%s\n",
3674 wxDateTime(29, wxDateTime::May
, 2099).Format(fmt
).c_str());
3677 static void TestTimeTicks()
3679 puts("\n*** wxDateTime ticks test ***");
3681 for ( size_t n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3683 const Date
& d
= testDates
[n
];
3684 if ( d
.ticks
== -1 )
3687 wxDateTime dt
= d
.DT();
3688 long ticks
= (dt
.GetValue() / 1000).ToLong();
3689 printf("Ticks of %s:\t% 10ld", d
.Format().c_str(), ticks
);
3690 if ( ticks
== d
.ticks
)
3696 printf(" (ERROR: should be %ld, delta = %ld)\n",
3697 d
.ticks
, ticks
- d
.ticks
);
3700 dt
= d
.DT().ToTimezone(wxDateTime::GMT0
);
3701 ticks
= (dt
.GetValue() / 1000).ToLong();
3702 printf("GMtks of %s:\t% 10ld", d
.Format().c_str(), ticks
);
3703 if ( ticks
== d
.gmticks
)
3709 printf(" (ERROR: should be %ld, delta = %ld)\n",
3710 d
.gmticks
, ticks
- d
.gmticks
);
3717 // test conversions to JDN &c
3718 static void TestTimeJDN()
3720 puts("\n*** wxDateTime to JDN test ***");
3722 for ( size_t n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3724 const Date
& d
= testDates
[n
];
3725 wxDateTime
dt(d
.day
, d
.month
, d
.year
, d
.hour
, d
.min
, d
.sec
);
3726 double jdn
= dt
.GetJulianDayNumber();
3728 printf("JDN of %s is:\t% 15.6f", d
.Format().c_str(), jdn
);
3735 printf(" (ERROR: should be %f, delta = %f)\n",
3736 d
.jdn
, jdn
- d
.jdn
);
3741 // test week days computation
3742 static void TestTimeWDays()
3744 puts("\n*** wxDateTime weekday test ***");
3746 // test GetWeekDay()
3748 for ( n
= 0; n
< WXSIZEOF(testDates
); n
++ )
3750 const Date
& d
= testDates
[n
];
3751 wxDateTime
dt(d
.day
, d
.month
, d
.year
, d
.hour
, d
.min
, d
.sec
);
3753 wxDateTime::WeekDay wday
= dt
.GetWeekDay();
3756 wxDateTime::GetWeekDayName(wday
).c_str());
3757 if ( wday
== d
.wday
)
3763 printf(" (ERROR: should be %s)\n",
3764 wxDateTime::GetWeekDayName(d
.wday
).c_str());
3770 // test SetToWeekDay()
3771 struct WeekDateTestData
3773 Date date
; // the real date (precomputed)
3774 int nWeek
; // its week index in the month
3775 wxDateTime::WeekDay wday
; // the weekday
3776 wxDateTime::Month month
; // the month
3777 int year
; // and the year
3779 wxString
Format() const
3782 switch ( nWeek
< -1 ? -nWeek
: nWeek
)
3784 case 1: which
= "first"; break;
3785 case 2: which
= "second"; break;
3786 case 3: which
= "third"; break;
3787 case 4: which
= "fourth"; break;
3788 case 5: which
= "fifth"; break;
3790 case -1: which
= "last"; break;
3795 which
+= " from end";
3798 s
.Printf("The %s %s of %s in %d",
3800 wxDateTime::GetWeekDayName(wday
).c_str(),
3801 wxDateTime::GetMonthName(month
).c_str(),
3808 // the array data was generated by the following python program
3810 from DateTime import *
3811 from whrandom import *
3812 from string import *
3814 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
3815 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
3817 week = DateTimeDelta(7)
3820 year = randint(1900, 2100)
3821 month = randint(1, 12)
3822 day = randint(1, 28)
3823 dt = DateTime(year, month, day)
3824 wday = dt.day_of_week
3826 countFromEnd = choice([-1, 1])
3829 while dt.month is month:
3830 dt = dt - countFromEnd * week
3831 weekNum = weekNum + countFromEnd
3833 data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
3835 print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
3836 "wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
3839 static const WeekDateTestData weekDatesTestData
[] =
3841 { { 20, wxDateTime::Mar
, 2045 }, 3, wxDateTime::Mon
, wxDateTime::Mar
, 2045 },
3842 { { 5, wxDateTime::Jun
, 1985 }, -4, wxDateTime::Wed
, wxDateTime::Jun
, 1985 },
3843 { { 12, wxDateTime::Nov
, 1961 }, -3, wxDateTime::Sun
, wxDateTime::Nov
, 1961 },
3844 { { 27, wxDateTime::Feb
, 2093 }, -1, wxDateTime::Fri
, wxDateTime::Feb
, 2093 },
3845 { { 4, wxDateTime::Jul
, 2070 }, -4, wxDateTime::Fri
, wxDateTime::Jul
, 2070 },
3846 { { 2, wxDateTime::Apr
, 1906 }, -5, wxDateTime::Mon
, wxDateTime::Apr
, 1906 },
3847 { { 19, wxDateTime::Jul
, 2023 }, -2, wxDateTime::Wed
, wxDateTime::Jul
, 2023 },
3848 { { 5, wxDateTime::May
, 1958 }, -4, wxDateTime::Mon
, wxDateTime::May
, 1958 },
3849 { { 11, wxDateTime::Aug
, 1900 }, 2, wxDateTime::Sat
, wxDateTime::Aug
, 1900 },
3850 { { 14, wxDateTime::Feb
, 1945 }, 2, wxDateTime::Wed
, wxDateTime::Feb
, 1945 },
3851 { { 25, wxDateTime::Jul
, 1967 }, -1, wxDateTime::Tue
, wxDateTime::Jul
, 1967 },
3852 { { 9, wxDateTime::May
, 1916 }, -4, wxDateTime::Tue
, wxDateTime::May
, 1916 },
3853 { { 20, wxDateTime::Jun
, 1927 }, 3, wxDateTime::Mon
, wxDateTime::Jun
, 1927 },
3854 { { 2, wxDateTime::Aug
, 2000 }, 1, wxDateTime::Wed
, wxDateTime::Aug
, 2000 },
3855 { { 20, wxDateTime::Apr
, 2044 }, 3, wxDateTime::Wed
, wxDateTime::Apr
, 2044 },
3856 { { 20, wxDateTime::Feb
, 1932 }, -2, wxDateTime::Sat
, wxDateTime::Feb
, 1932 },
3857 { { 25, wxDateTime::Jul
, 2069 }, 4, wxDateTime::Thu
, wxDateTime::Jul
, 2069 },
3858 { { 3, wxDateTime::Apr
, 1925 }, 1, wxDateTime::Fri
, wxDateTime::Apr
, 1925 },
3859 { { 21, wxDateTime::Mar
, 2093 }, 3, wxDateTime::Sat
, wxDateTime::Mar
, 2093 },
3860 { { 3, wxDateTime::Dec
, 2074 }, -5, wxDateTime::Mon
, wxDateTime::Dec
, 2074 },
3863 static const char *fmt
= "%d-%b-%Y";
3866 for ( n
= 0; n
< WXSIZEOF(weekDatesTestData
); n
++ )
3868 const WeekDateTestData
& wd
= weekDatesTestData
[n
];
3870 dt
.SetToWeekDay(wd
.wday
, wd
.nWeek
, wd
.month
, wd
.year
);
3872 printf("%s is %s", wd
.Format().c_str(), dt
.Format(fmt
).c_str());
3874 const Date
& d
= wd
.date
;
3875 if ( d
.SameDay(dt
.GetTm()) )
3881 dt
.Set(d
.day
, d
.month
, d
.year
);
3883 printf(" (ERROR: should be %s)\n", dt
.Format(fmt
).c_str());
3888 // test the computation of (ISO) week numbers
3889 static void TestTimeWNumber()
3891 puts("\n*** wxDateTime week number test ***");
3893 struct WeekNumberTestData
3895 Date date
; // the date
3896 wxDateTime::wxDateTime_t week
; // the week number in the year
3897 wxDateTime::wxDateTime_t wmon
; // the week number in the month
3898 wxDateTime::wxDateTime_t wmon2
; // same but week starts with Sun
3899 wxDateTime::wxDateTime_t dnum
; // day number in the year
3902 // data generated with the following python script:
3904 from DateTime import *
3905 from whrandom import *
3906 from string import *
3908 monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
3909 wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
3911 def GetMonthWeek(dt):
3912 weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
3913 if weekNumMonth < 0:
3914 weekNumMonth = weekNumMonth + 53
3917 def GetLastSundayBefore(dt):
3918 if dt.iso_week[2] == 7:
3921 return dt - DateTimeDelta(dt.iso_week[2])
3924 year = randint(1900, 2100)
3925 month = randint(1, 12)
3926 day = randint(1, 28)
3927 dt = DateTime(year, month, day)
3928 dayNum = dt.day_of_year
3929 weekNum = dt.iso_week[1]
3930 weekNumMonth = GetMonthWeek(dt)
3933 dtSunday = GetLastSundayBefore(dt)
3935 while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
3936 weekNumMonth2 = weekNumMonth2 + 1
3937 dtSunday = dtSunday - DateTimeDelta(7)
3939 data = { 'day': rjust(`day`, 2), \
3940 'month': monthNames[month - 1], \
3942 'weekNum': rjust(`weekNum`, 2), \
3943 'weekNumMonth': weekNumMonth, \
3944 'weekNumMonth2': weekNumMonth2, \
3945 'dayNum': rjust(`dayNum`, 3) }
3947 print " { { %(day)s, "\
3948 "wxDateTime::%(month)s, "\
3951 "%(weekNumMonth)s, "\
3952 "%(weekNumMonth2)s, "\
3953 "%(dayNum)s }," % data
3956 static const WeekNumberTestData weekNumberTestDates
[] =
3958 { { 27, wxDateTime::Dec
, 1966 }, 52, 5, 5, 361 },
3959 { { 22, wxDateTime::Jul
, 1926 }, 29, 4, 4, 203 },
3960 { { 22, wxDateTime::Oct
, 2076 }, 43, 4, 4, 296 },
3961 { { 1, wxDateTime::Jul
, 1967 }, 26, 1, 1, 182 },
3962 { { 8, wxDateTime::Nov
, 2004 }, 46, 2, 2, 313 },
3963 { { 21, wxDateTime::Mar
, 1920 }, 12, 3, 4, 81 },
3964 { { 7, wxDateTime::Jan
, 1965 }, 1, 2, 2, 7 },
3965 { { 19, wxDateTime::Oct
, 1999 }, 42, 4, 4, 292 },
3966 { { 13, wxDateTime::Aug
, 1955 }, 32, 2, 2, 225 },
3967 { { 18, wxDateTime::Jul
, 2087 }, 29, 3, 3, 199 },
3968 { { 2, wxDateTime::Sep
, 2028 }, 35, 1, 1, 246 },
3969 { { 28, wxDateTime::Jul
, 1945 }, 30, 5, 4, 209 },
3970 { { 15, wxDateTime::Jun
, 1901 }, 24, 3, 3, 166 },
3971 { { 10, wxDateTime::Oct
, 1939 }, 41, 3, 2, 283 },
3972 { { 3, wxDateTime::Dec
, 1965 }, 48, 1, 1, 337 },
3973 { { 23, wxDateTime::Feb
, 1940 }, 8, 4, 4, 54 },
3974 { { 2, wxDateTime::Jan
, 1987 }, 1, 1, 1, 2 },
3975 { { 11, wxDateTime::Aug
, 2079 }, 32, 2, 2, 223 },
3976 { { 2, wxDateTime::Feb
, 2063 }, 5, 1, 1, 33 },
3977 { { 16, wxDateTime::Oct
, 1942 }, 42, 3, 3, 289 },
3980 for ( size_t n
= 0; n
< WXSIZEOF(weekNumberTestDates
); n
++ )
3982 const WeekNumberTestData
& wn
= weekNumberTestDates
[n
];
3983 const Date
& d
= wn
.date
;
3985 wxDateTime dt
= d
.DT();
3987 wxDateTime::wxDateTime_t
3988 week
= dt
.GetWeekOfYear(wxDateTime::Monday_First
),
3989 wmon
= dt
.GetWeekOfMonth(wxDateTime::Monday_First
),
3990 wmon2
= dt
.GetWeekOfMonth(wxDateTime::Sunday_First
),
3991 dnum
= dt
.GetDayOfYear();
3993 printf("%s: the day number is %d",
3994 d
.FormatDate().c_str(), dnum
);
3995 if ( dnum
== wn
.dnum
)
4001 printf(" (ERROR: should be %d)", wn
.dnum
);
4004 printf(", week in month is %d", wmon
);
4005 if ( wmon
== wn
.wmon
)
4011 printf(" (ERROR: should be %d)", wn
.wmon
);
4014 printf(" or %d", wmon2
);
4015 if ( wmon2
== wn
.wmon2
)
4021 printf(" (ERROR: should be %d)", wn
.wmon2
);
4024 printf(", week in year is %d", week
);
4025 if ( week
== wn
.week
)
4031 printf(" (ERROR: should be %d)\n", wn
.week
);
4036 // test DST calculations
4037 static void TestTimeDST()
4039 puts("\n*** wxDateTime DST test ***");
4041 printf("DST is%s in effect now.\n\n",
4042 wxDateTime::Now().IsDST() ? "" : " not");
4044 // taken from http://www.energy.ca.gov/daylightsaving.html
4045 static const Date datesDST
[2][2004 - 1900 + 1] =
4048 { 1, wxDateTime::Apr
, 1990 },
4049 { 7, wxDateTime::Apr
, 1991 },
4050 { 5, wxDateTime::Apr
, 1992 },
4051 { 4, wxDateTime::Apr
, 1993 },
4052 { 3, wxDateTime::Apr
, 1994 },
4053 { 2, wxDateTime::Apr
, 1995 },
4054 { 7, wxDateTime::Apr
, 1996 },
4055 { 6, wxDateTime::Apr
, 1997 },
4056 { 5, wxDateTime::Apr
, 1998 },
4057 { 4, wxDateTime::Apr
, 1999 },
4058 { 2, wxDateTime::Apr
, 2000 },
4059 { 1, wxDateTime::Apr
, 2001 },
4060 { 7, wxDateTime::Apr
, 2002 },
4061 { 6, wxDateTime::Apr
, 2003 },
4062 { 4, wxDateTime::Apr
, 2004 },
4065 { 28, wxDateTime::Oct
, 1990 },
4066 { 27, wxDateTime::Oct
, 1991 },
4067 { 25, wxDateTime::Oct
, 1992 },
4068 { 31, wxDateTime::Oct
, 1993 },
4069 { 30, wxDateTime::Oct
, 1994 },
4070 { 29, wxDateTime::Oct
, 1995 },
4071 { 27, wxDateTime::Oct
, 1996 },
4072 { 26, wxDateTime::Oct
, 1997 },
4073 { 25, wxDateTime::Oct
, 1998 },
4074 { 31, wxDateTime::Oct
, 1999 },
4075 { 29, wxDateTime::Oct
, 2000 },
4076 { 28, wxDateTime::Oct
, 2001 },
4077 { 27, wxDateTime::Oct
, 2002 },
4078 { 26, wxDateTime::Oct
, 2003 },
4079 { 31, wxDateTime::Oct
, 2004 },
4084 for ( year
= 1990; year
< 2005; year
++ )
4086 wxDateTime dtBegin
= wxDateTime::GetBeginDST(year
, wxDateTime::USA
),
4087 dtEnd
= wxDateTime::GetEndDST(year
, wxDateTime::USA
);
4089 printf("DST period in the US for year %d: from %s to %s",
4090 year
, dtBegin
.Format().c_str(), dtEnd
.Format().c_str());
4092 size_t n
= year
- 1990;
4093 const Date
& dBegin
= datesDST
[0][n
];
4094 const Date
& dEnd
= datesDST
[1][n
];
4096 if ( dBegin
.SameDay(dtBegin
.GetTm()) && dEnd
.SameDay(dtEnd
.GetTm()) )
4102 printf(" (ERROR: should be %s %d to %s %d)\n",
4103 wxDateTime::GetMonthName(dBegin
.month
).c_str(), dBegin
.day
,
4104 wxDateTime::GetMonthName(dEnd
.month
).c_str(), dEnd
.day
);
4110 for ( year
= 1990; year
< 2005; year
++ )
4112 printf("DST period in Europe for year %d: from %s to %s\n",
4114 wxDateTime::GetBeginDST(year
, wxDateTime::Country_EEC
).Format().c_str(),
4115 wxDateTime::GetEndDST(year
, wxDateTime::Country_EEC
).Format().c_str());
4119 // test wxDateTime -> text conversion
4120 static void TestTimeFormat()
4122 puts("\n*** wxDateTime formatting test ***");
4124 // some information may be lost during conversion, so store what kind
4125 // of info should we recover after a round trip
4128 CompareNone
, // don't try comparing
4129 CompareBoth
, // dates and times should be identical
4130 CompareDate
, // dates only
4131 CompareTime
// time only
4136 CompareKind compareKind
;
4138 } formatTestFormats
[] =
4140 { CompareBoth
, "---> %c" },
4141 { CompareDate
, "Date is %A, %d of %B, in year %Y" },
4142 { CompareBoth
, "Date is %x, time is %X" },
4143 { CompareTime
, "Time is %H:%M:%S or %I:%M:%S %p" },
4144 { CompareNone
, "The day of year: %j, the week of year: %W" },
4145 { CompareDate
, "ISO date without separators: %4Y%2m%2d" },
4148 static const Date formatTestDates
[] =
4150 { 29, wxDateTime::May
, 1976, 18, 30, 00 },
4151 { 31, wxDateTime::Dec
, 1999, 23, 30, 00 },
4153 // this test can't work for other centuries because it uses two digit
4154 // years in formats, so don't even try it
4155 { 29, wxDateTime::May
, 2076, 18, 30, 00 },
4156 { 29, wxDateTime::Feb
, 2400, 02, 15, 25 },
4157 { 01, wxDateTime::Jan
, -52, 03, 16, 47 },
4161 // an extra test (as it doesn't depend on date, don't do it in the loop)
4162 printf("%s\n", wxDateTime::Now().Format("Our timezone is %Z").c_str());
4164 for ( size_t d
= 0; d
< WXSIZEOF(formatTestDates
) + 1; d
++ )
4168 wxDateTime dt
= d
== 0 ? wxDateTime::Now() : formatTestDates
[d
- 1].DT();
4169 for ( size_t n
= 0; n
< WXSIZEOF(formatTestFormats
); n
++ )
4171 wxString s
= dt
.Format(formatTestFormats
[n
].format
);
4172 printf("%s", s
.c_str());
4174 // what can we recover?
4175 int kind
= formatTestFormats
[n
].compareKind
;
4179 const wxChar
*result
= dt2
.ParseFormat(s
, formatTestFormats
[n
].format
);
4182 // converion failed - should it have?
4183 if ( kind
== CompareNone
)
4186 puts(" (ERROR: conversion back failed)");
4190 // should have parsed the entire string
4191 puts(" (ERROR: conversion back stopped too soon)");
4195 bool equal
= FALSE
; // suppress compilaer warning
4203 equal
= dt
.IsSameDate(dt2
);
4207 equal
= dt
.IsSameTime(dt2
);
4213 printf(" (ERROR: got back '%s' instead of '%s')\n",
4214 dt2
.Format().c_str(), dt
.Format().c_str());
4225 // test text -> wxDateTime conversion
4226 static void TestTimeParse()
4228 puts("\n*** wxDateTime parse test ***");
4230 struct ParseTestData
4237 static const ParseTestData parseTestDates
[] =
4239 { "Sat, 18 Dec 1999 00:46:40 +0100", { 18, wxDateTime::Dec
, 1999, 00, 46, 40 }, TRUE
},
4240 { "Wed, 1 Dec 1999 05:17:20 +0300", { 1, wxDateTime::Dec
, 1999, 03, 17, 20 }, TRUE
},
4243 for ( size_t n
= 0; n
< WXSIZEOF(parseTestDates
); n
++ )
4245 const char *format
= parseTestDates
[n
].format
;
4247 printf("%s => ", format
);
4250 if ( dt
.ParseRfc822Date(format
) )
4252 printf("%s ", dt
.Format().c_str());
4254 if ( parseTestDates
[n
].good
)
4256 wxDateTime dtReal
= parseTestDates
[n
].date
.DT();
4263 printf("(ERROR: should be %s)\n", dtReal
.Format().c_str());
4268 puts("(ERROR: bad format)");
4273 printf("bad format (%s)\n",
4274 parseTestDates
[n
].good
? "ERROR" : "ok");
4279 static void TestDateTimeInteractive()
4281 puts("\n*** interactive wxDateTime tests ***");
4287 printf("Enter a date: ");
4288 if ( !fgets(buf
, WXSIZEOF(buf
), stdin
) )
4291 // kill the last '\n'
4292 buf
[strlen(buf
) - 1] = 0;
4295 const char *p
= dt
.ParseDate(buf
);
4298 printf("ERROR: failed to parse the date '%s'.\n", buf
);
4304 printf("WARNING: parsed only first %u characters.\n", p
- buf
);
4307 printf("%s: day %u, week of month %u/%u, week of year %u\n",
4308 dt
.Format("%b %d, %Y").c_str(),
4310 dt
.GetWeekOfMonth(wxDateTime::Monday_First
),
4311 dt
.GetWeekOfMonth(wxDateTime::Sunday_First
),
4312 dt
.GetWeekOfYear(wxDateTime::Monday_First
));
4315 puts("\n*** done ***");
4318 static void TestTimeMS()
4320 puts("*** testing millisecond-resolution support in wxDateTime ***");
4322 wxDateTime dt1
= wxDateTime::Now(),
4323 dt2
= wxDateTime::UNow();
4325 printf("Now = %s\n", dt1
.Format("%H:%M:%S:%l").c_str());
4326 printf("UNow = %s\n", dt2
.Format("%H:%M:%S:%l").c_str());
4327 printf("Dummy loop: ");
4328 for ( int i
= 0; i
< 6000; i
++ )
4330 //for ( int j = 0; j < 10; j++ )
4333 s
.Printf("%g", sqrt(i
));
4342 dt2
= wxDateTime::UNow();
4343 printf("UNow = %s\n", dt2
.Format("%H:%M:%S:%l").c_str());
4345 printf("Loop executed in %s ms\n", (dt2
- dt1
).Format("%l").c_str());
4347 puts("\n*** done ***");
4350 static void TestTimeArithmetics()
4352 puts("\n*** testing arithmetic operations on wxDateTime ***");
4354 static const struct ArithmData
4356 ArithmData(const wxDateSpan
& sp
, const char *nam
)
4357 : span(sp
), name(nam
) { }
4361 } testArithmData
[] =
4363 ArithmData(wxDateSpan::Day(), "day"),
4364 ArithmData(wxDateSpan::Week(), "week"),
4365 ArithmData(wxDateSpan::Month(), "month"),
4366 ArithmData(wxDateSpan::Year(), "year"),
4367 ArithmData(wxDateSpan(1, 2, 3, 4), "year, 2 months, 3 weeks, 4 days"),
4370 wxDateTime
dt(29, wxDateTime::Dec
, 1999), dt1
, dt2
;
4372 for ( size_t n
= 0; n
< WXSIZEOF(testArithmData
); n
++ )
4374 wxDateSpan span
= testArithmData
[n
].span
;
4378 const char *name
= testArithmData
[n
].name
;
4379 printf("%s + %s = %s, %s - %s = %s\n",
4380 dt
.FormatISODate().c_str(), name
, dt1
.FormatISODate().c_str(),
4381 dt
.FormatISODate().c_str(), name
, dt2
.FormatISODate().c_str());
4383 printf("Going back: %s", (dt1
- span
).FormatISODate().c_str());
4384 if ( dt1
- span
== dt
)
4390 printf(" (ERROR: should be %s)\n", dt
.FormatISODate().c_str());
4393 printf("Going forward: %s", (dt2
+ span
).FormatISODate().c_str());
4394 if ( dt2
+ span
== dt
)
4400 printf(" (ERROR: should be %s)\n", dt
.FormatISODate().c_str());
4403 printf("Double increment: %s", (dt2
+ 2*span
).FormatISODate().c_str());
4404 if ( dt2
+ 2*span
== dt1
)
4410 printf(" (ERROR: should be %s)\n", dt2
.FormatISODate().c_str());
4417 static void TestTimeHolidays()
4419 puts("\n*** testing wxDateTimeHolidayAuthority ***\n");
4421 wxDateTime::Tm tm
= wxDateTime(29, wxDateTime::May
, 2000).GetTm();
4422 wxDateTime
dtStart(1, tm
.mon
, tm
.year
),
4423 dtEnd
= dtStart
.GetLastMonthDay();
4425 wxDateTimeArray hol
;
4426 wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart
, dtEnd
, hol
);
4428 const wxChar
*format
= "%d-%b-%Y (%a)";
4430 printf("All holidays between %s and %s:\n",
4431 dtStart
.Format(format
).c_str(), dtEnd
.Format(format
).c_str());
4433 size_t count
= hol
.GetCount();
4434 for ( size_t n
= 0; n
< count
; n
++ )
4436 printf("\t%s\n", hol
[n
].Format(format
).c_str());
4442 static void TestTimeZoneBug()
4444 puts("\n*** testing for DST/timezone bug ***\n");
4446 wxDateTime date
= wxDateTime(1, wxDateTime::Mar
, 2000);
4447 for ( int i
= 0; i
< 31; i
++ )
4449 printf("Date %s: week day %s.\n",
4450 date
.Format(_T("%d-%m-%Y")).c_str(),
4451 date
.GetWeekDayName(date
.GetWeekDay()).c_str());
4453 date
+= wxDateSpan::Day();
4459 static void TestTimeSpanFormat()
4461 puts("\n*** wxTimeSpan tests ***");
4463 static const char *formats
[] =
4465 _T("(default) %H:%M:%S"),
4466 _T("%E weeks and %D days"),
4467 _T("%l milliseconds"),
4468 _T("(with ms) %H:%M:%S:%l"),
4469 _T("100%% of minutes is %M"), // test "%%"
4470 _T("%D days and %H hours"),
4471 _T("or also %S seconds"),
4474 wxTimeSpan
ts1(1, 2, 3, 4),
4476 for ( size_t n
= 0; n
< WXSIZEOF(formats
); n
++ )
4478 printf("ts1 = %s\tts2 = %s\n",
4479 ts1
.Format(formats
[n
]).c_str(),
4480 ts2
.Format(formats
[n
]).c_str());
4488 // test compatibility with the old wxDate/wxTime classes
4489 static void TestTimeCompatibility()
4491 puts("\n*** wxDateTime compatibility test ***");
4493 printf("wxDate for JDN 0: %s\n", wxDate(0l).FormatDate().c_str());
4494 printf("wxDate for MJD 0: %s\n", wxDate(2400000).FormatDate().c_str());
4496 double jdnNow
= wxDateTime::Now().GetJDN();
4497 long jdnMidnight
= (long)(jdnNow
- 0.5);
4498 printf("wxDate for today: %s\n", wxDate(jdnMidnight
).FormatDate().c_str());
4500 jdnMidnight
= wxDate().Set().GetJulianDate();
4501 printf("wxDateTime for today: %s\n",
4502 wxDateTime((double)(jdnMidnight
+ 0.5)).Format("%c", wxDateTime::GMT0
).c_str());
4504 int flags
= wxEUROPEAN
;//wxFULL;
4507 printf("Today is %s\n", date
.FormatDate(flags
).c_str());
4508 for ( int n
= 0; n
< 7; n
++ )
4510 printf("Previous %s is %s\n",
4511 wxDateTime::GetWeekDayName((wxDateTime::WeekDay
)n
),
4512 date
.Previous(n
+ 1).FormatDate(flags
).c_str());
4518 #endif // TEST_DATETIME
4520 // ----------------------------------------------------------------------------
4522 // ----------------------------------------------------------------------------
4526 #include "wx/thread.h"
4528 static size_t gs_counter
= (size_t)-1;
4529 static wxCriticalSection gs_critsect
;
4530 static wxCondition gs_cond
;
4532 class MyJoinableThread
: public wxThread
4535 MyJoinableThread(size_t n
) : wxThread(wxTHREAD_JOINABLE
)
4536 { m_n
= n
; Create(); }
4538 // thread execution starts here
4539 virtual ExitCode
Entry();
4545 wxThread::ExitCode
MyJoinableThread::Entry()
4547 unsigned long res
= 1;
4548 for ( size_t n
= 1; n
< m_n
; n
++ )
4552 // it's a loooong calculation :-)
4556 return (ExitCode
)res
;
4559 class MyDetachedThread
: public wxThread
4562 MyDetachedThread(size_t n
, char ch
)
4566 m_cancelled
= FALSE
;
4571 // thread execution starts here
4572 virtual ExitCode
Entry();
4575 virtual void OnExit();
4578 size_t m_n
; // number of characters to write
4579 char m_ch
; // character to write
4581 bool m_cancelled
; // FALSE if we exit normally
4584 wxThread::ExitCode
MyDetachedThread::Entry()
4587 wxCriticalSectionLocker
lock(gs_critsect
);
4588 if ( gs_counter
== (size_t)-1 )
4594 for ( size_t n
= 0; n
< m_n
; n
++ )
4596 if ( TestDestroy() )
4606 wxThread::Sleep(100);
4612 void MyDetachedThread::OnExit()
4614 wxLogTrace("thread", "Thread %ld is in OnExit", GetId());
4616 wxCriticalSectionLocker
lock(gs_critsect
);
4617 if ( !--gs_counter
&& !m_cancelled
)
4621 static void TestDetachedThreads()
4623 puts("\n*** Testing detached threads ***");
4625 static const size_t nThreads
= 3;
4626 MyDetachedThread
*threads
[nThreads
];
4628 for ( n
= 0; n
< nThreads
; n
++ )
4630 threads
[n
] = new MyDetachedThread(10, 'A' + n
);
4633 threads
[0]->SetPriority(WXTHREAD_MIN_PRIORITY
);
4634 threads
[1]->SetPriority(WXTHREAD_MAX_PRIORITY
);
4636 for ( n
= 0; n
< nThreads
; n
++ )
4641 // wait until all threads terminate
4647 static void TestJoinableThreads()
4649 puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
4651 // calc 10! in the background
4652 MyJoinableThread
thread(10);
4655 printf("\nThread terminated with exit code %lu.\n",
4656 (unsigned long)thread
.Wait());
4659 static void TestThreadSuspend()
4661 puts("\n*** Testing thread suspend/resume functions ***");
4663 MyDetachedThread
*thread
= new MyDetachedThread(15, 'X');
4667 // this is for this demo only, in a real life program we'd use another
4668 // condition variable which would be signaled from wxThread::Entry() to
4669 // tell us that the thread really started running - but here just wait a
4670 // bit and hope that it will be enough (the problem is, of course, that
4671 // the thread might still not run when we call Pause() which will result
4673 wxThread::Sleep(300);
4675 for ( size_t n
= 0; n
< 3; n
++ )
4679 puts("\nThread suspended");
4682 // don't sleep but resume immediately the first time
4683 wxThread::Sleep(300);
4685 puts("Going to resume the thread");
4690 puts("Waiting until it terminates now");
4692 // wait until the thread terminates
4698 static void TestThreadDelete()
4700 // As above, using Sleep() is only for testing here - we must use some
4701 // synchronisation object instead to ensure that the thread is still
4702 // running when we delete it - deleting a detached thread which already
4703 // terminated will lead to a crash!
4705 puts("\n*** Testing thread delete function ***");
4707 MyDetachedThread
*thread0
= new MyDetachedThread(30, 'W');
4711 puts("\nDeleted a thread which didn't start to run yet.");
4713 MyDetachedThread
*thread1
= new MyDetachedThread(30, 'Y');
4717 wxThread::Sleep(300);
4721 puts("\nDeleted a running thread.");
4723 MyDetachedThread
*thread2
= new MyDetachedThread(30, 'Z');
4727 wxThread::Sleep(300);
4733 puts("\nDeleted a sleeping thread.");
4735 MyJoinableThread
thread3(20);
4740 puts("\nDeleted a joinable thread.");
4742 MyJoinableThread
thread4(2);
4745 wxThread::Sleep(300);
4749 puts("\nDeleted a joinable thread which already terminated.");
4754 class MyWaitingThread
: public wxThread
4757 MyWaitingThread(wxCondition
*condition
)
4759 m_condition
= condition
;
4764 virtual ExitCode
Entry()
4766 printf("Thread %lu has started running.\n", GetId());
4771 printf("Thread %lu starts to wait...\n", GetId());
4774 m_condition
->Wait();
4776 printf("Thread %lu finished to wait, exiting.\n", GetId());
4783 wxCondition
*m_condition
;
4786 static void TestThreadConditions()
4788 wxCondition condition
;
4790 // otherwise its difficult to understand which log messages pertain to
4792 wxLogTrace("thread", "Local condition var is %08x, gs_cond = %08x",
4793 condition
.GetId(), gs_cond
.GetId());
4795 // create and launch threads
4796 MyWaitingThread
*threads
[10];
4799 for ( n
= 0; n
< WXSIZEOF(threads
); n
++ )
4801 threads
[n
] = new MyWaitingThread(&condition
);
4804 for ( n
= 0; n
< WXSIZEOF(threads
); n
++ )
4809 // wait until all threads run
4810 puts("Main thread is waiting for the other threads to start");
4813 size_t nRunning
= 0;
4814 while ( nRunning
< WXSIZEOF(threads
) )
4820 printf("Main thread: %u already running\n", nRunning
);
4824 puts("Main thread: all threads started up.");
4827 wxThread::Sleep(500);
4830 // now wake one of them up
4831 printf("Main thread: about to signal the condition.\n");
4836 wxThread::Sleep(200);
4838 // wake all the (remaining) threads up, so that they can exit
4839 printf("Main thread: about to broadcast the condition.\n");
4841 condition
.Broadcast();
4843 // give them time to terminate (dirty!)
4844 wxThread::Sleep(500);
4847 #endif // TEST_THREADS
4849 // ----------------------------------------------------------------------------
4851 // ----------------------------------------------------------------------------
4855 static void PrintArray(const char* name
, const wxArrayString
& array
)
4857 printf("Dump of the array '%s'\n", name
);
4859 size_t nCount
= array
.GetCount();
4860 for ( size_t n
= 0; n
< nCount
; n
++ )
4862 printf("\t%s[%u] = '%s'\n", name
, n
, array
[n
].c_str());
4866 static void PrintArray(const char* name
, const wxArrayInt
& array
)
4868 printf("Dump of the array '%s'\n", name
);
4870 size_t nCount
= array
.GetCount();
4871 for ( size_t n
= 0; n
< nCount
; n
++ )
4873 printf("\t%s[%u] = %d\n", name
, n
, array
[n
]);
4877 int wxCMPFUNC_CONV
StringLenCompare(const wxString
& first
,
4878 const wxString
& second
)
4880 return first
.length() - second
.length();
4883 int wxCMPFUNC_CONV
IntCompare(int *first
,
4886 return *first
- *second
;
4889 int wxCMPFUNC_CONV
IntRevCompare(int *first
,
4892 return *second
- *first
;
4895 static void TestArrayOfInts()
4897 puts("*** Testing wxArrayInt ***\n");
4908 puts("After sort:");
4912 puts("After reverse sort:");
4913 a
.Sort(IntRevCompare
);
4917 #include "wx/dynarray.h"
4919 WX_DECLARE_OBJARRAY(Bar
, ArrayBars
);
4920 #include "wx/arrimpl.cpp"
4921 WX_DEFINE_OBJARRAY(ArrayBars
);
4923 static void TestArrayOfObjects()
4925 puts("*** Testing wxObjArray ***\n");
4929 Bar
bar("second bar");
4931 printf("Initially: %u objects in the array, %u objects total.\n",
4932 bars
.GetCount(), Bar::GetNumber());
4934 bars
.Add(new Bar("first bar"));
4937 printf("Now: %u objects in the array, %u objects total.\n",
4938 bars
.GetCount(), Bar::GetNumber());
4942 printf("After Empty(): %u objects in the array, %u objects total.\n",
4943 bars
.GetCount(), Bar::GetNumber());
4946 printf("Finally: no more objects in the array, %u objects total.\n",
4950 #endif // TEST_ARRAYS
4952 // ----------------------------------------------------------------------------
4954 // ----------------------------------------------------------------------------
4958 #include "wx/timer.h"
4959 #include "wx/tokenzr.h"
4961 static void TestStringConstruction()
4963 puts("*** Testing wxString constructores ***");
4965 #define TEST_CTOR(args, res) \
4968 printf("wxString%s = %s ", #args, s.c_str()); \
4975 printf("(ERROR: should be %s)\n", res); \
4979 TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
4980 TEST_CTOR((_T("Hello"), 4), _T("Hell"));
4981 TEST_CTOR((_T("Hello"), 5), _T("Hello"));
4982 // TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
4984 static const wxChar
*s
= _T("?really!");
4985 const wxChar
*start
= wxStrchr(s
, _T('r'));
4986 const wxChar
*end
= wxStrchr(s
, _T('!'));
4987 TEST_CTOR((start
, end
), _T("really"));
4992 static void TestString()
5002 for (int i
= 0; i
< 1000000; ++i
)
5006 c
= "! How'ya doin'?";
5009 c
= "Hello world! What's up?";
5014 printf ("TestString elapsed time: %ld\n", sw
.Time());
5017 static void TestPChar()
5025 for (int i
= 0; i
< 1000000; ++i
)
5027 strcpy (a
, "Hello");
5028 strcpy (b
, " world");
5029 strcpy (c
, "! How'ya doin'?");
5032 strcpy (c
, "Hello world! What's up?");
5033 if (strcmp (c
, a
) == 0)
5037 printf ("TestPChar elapsed time: %ld\n", sw
.Time());
5040 static void TestStringSub()
5042 wxString
s("Hello, world!");
5044 puts("*** Testing wxString substring extraction ***");
5046 printf("String = '%s'\n", s
.c_str());
5047 printf("Left(5) = '%s'\n", s
.Left(5).c_str());
5048 printf("Right(6) = '%s'\n", s
.Right(6).c_str());
5049 printf("Mid(3, 5) = '%s'\n", s(3, 5).c_str());
5050 printf("Mid(3) = '%s'\n", s
.Mid(3).c_str());
5051 printf("substr(3, 5) = '%s'\n", s
.substr(3, 5).c_str());
5052 printf("substr(3) = '%s'\n", s
.substr(3).c_str());
5054 static const wxChar
*prefixes
[] =
5058 _T("Hello, world!"),
5059 _T("Hello, world!!!"),
5065 for ( size_t n
= 0; n
< WXSIZEOF(prefixes
); n
++ )
5067 wxString prefix
= prefixes
[n
], rest
;
5068 bool rc
= s
.StartsWith(prefix
, &rest
);
5069 printf("StartsWith('%s') = %s", prefix
.c_str(), rc
? "TRUE" : "FALSE");
5072 printf(" (the rest is '%s')\n", rest
.c_str());
5083 static void TestStringFormat()
5085 puts("*** Testing wxString formatting ***");
5088 s
.Printf("%03d", 18);
5090 printf("Number 18: %s\n", wxString::Format("%03d", 18).c_str());
5091 printf("Number 18: %s\n", s
.c_str());
5096 // returns "not found" for npos, value for all others
5097 static wxString
PosToString(size_t res
)
5099 wxString s
= res
== wxString::npos
? wxString(_T("not found"))
5100 : wxString::Format(_T("%u"), res
);
5104 static void TestStringFind()
5106 puts("*** Testing wxString find() functions ***");
5108 static const wxChar
*strToFind
= _T("ell");
5109 static const struct StringFindTest
5113 result
; // of searching "ell" in str
5116 { _T("Well, hello world"), 0, 1 },
5117 { _T("Well, hello world"), 6, 7 },
5118 { _T("Well, hello world"), 9, wxString::npos
},
5121 for ( size_t n
= 0; n
< WXSIZEOF(findTestData
); n
++ )
5123 const StringFindTest
& ft
= findTestData
[n
];
5124 size_t res
= wxString(ft
.str
).find(strToFind
, ft
.start
);
5126 printf(_T("Index of '%s' in '%s' starting from %u is %s "),
5127 strToFind
, ft
.str
, ft
.start
, PosToString(res
).c_str());
5129 size_t resTrue
= ft
.result
;
5130 if ( res
== resTrue
)
5136 printf(_T("(ERROR: should be %s)\n"),
5137 PosToString(resTrue
).c_str());
5144 static void TestStringTokenizer()
5146 puts("*** Testing wxStringTokenizer ***");
5148 static const wxChar
*modeNames
[] =
5152 _T("return all empty"),
5157 static const struct StringTokenizerTest
5159 const wxChar
*str
; // string to tokenize
5160 const wxChar
*delims
; // delimiters to use
5161 size_t count
; // count of token
5162 wxStringTokenizerMode mode
; // how should we tokenize it
5163 } tokenizerTestData
[] =
5165 { _T(""), _T(" "), 0 },
5166 { _T("Hello, world"), _T(" "), 2 },
5167 { _T("Hello, world "), _T(" "), 2 },
5168 { _T("Hello, world"), _T(","), 2 },
5169 { _T("Hello, world!"), _T(",!"), 2 },
5170 { _T("Hello,, world!"), _T(",!"), 3 },
5171 { _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL
},
5172 { _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
5173 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS
, 4 },
5174 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS
, 6, wxTOKEN_RET_EMPTY
},
5175 { _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS
, 9, wxTOKEN_RET_EMPTY_ALL
},
5176 { _T("01/02/99"), _T("/-"), 3 },
5177 { _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS
},
5180 for ( size_t n
= 0; n
< WXSIZEOF(tokenizerTestData
); n
++ )
5182 const StringTokenizerTest
& tt
= tokenizerTestData
[n
];
5183 wxStringTokenizer
tkz(tt
.str
, tt
.delims
, tt
.mode
);
5185 size_t count
= tkz
.CountTokens();
5186 printf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
5187 MakePrintable(tt
.str
).c_str(),
5189 MakePrintable(tt
.delims
).c_str(),
5190 modeNames
[tkz
.GetMode()]);
5191 if ( count
== tt
.count
)
5197 printf(_T("(ERROR: should be %u)\n"), tt
.count
);
5202 // if we emulate strtok(), check that we do it correctly
5203 wxChar
*buf
, *s
= NULL
, *last
;
5205 if ( tkz
.GetMode() == wxTOKEN_STRTOK
)
5207 buf
= new wxChar
[wxStrlen(tt
.str
) + 1];
5208 wxStrcpy(buf
, tt
.str
);
5210 s
= wxStrtok(buf
, tt
.delims
, &last
);
5217 // now show the tokens themselves
5219 while ( tkz
.HasMoreTokens() )
5221 wxString token
= tkz
.GetNextToken();
5223 printf(_T("\ttoken %u: '%s'"),
5225 MakePrintable(token
).c_str());
5235 printf(" (ERROR: should be %s)\n", s
);
5238 s
= wxStrtok(NULL
, tt
.delims
, &last
);
5242 // nothing to compare with
5247 if ( count2
!= count
)
5249 puts(_T("\tERROR: token count mismatch"));
5258 static void TestStringReplace()
5260 puts("*** Testing wxString::replace ***");
5262 static const struct StringReplaceTestData
5264 const wxChar
*original
; // original test string
5265 size_t start
, len
; // the part to replace
5266 const wxChar
*replacement
; // the replacement string
5267 const wxChar
*result
; // and the expected result
5268 } stringReplaceTestData
[] =
5270 { _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
5271 { _T("increase"), 0, 2, _T("de"), _T("decrease") },
5272 { _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
5273 { _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
5274 { _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
5277 for ( size_t n
= 0; n
< WXSIZEOF(stringReplaceTestData
); n
++ )
5279 const StringReplaceTestData data
= stringReplaceTestData
[n
];
5281 wxString original
= data
.original
;
5282 original
.replace(data
.start
, data
.len
, data
.replacement
);
5284 wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
5285 data
.original
, data
.start
, data
.len
, data
.replacement
,
5288 if ( original
== data
.result
)
5294 wxPrintf(_T("(ERROR: should be '%s')\n"), data
.result
);
5301 static void TestStringMatch()
5303 wxPuts(_T("*** Testing wxString::Matches() ***"));
5305 static const struct StringMatchTestData
5308 const wxChar
*wildcard
;
5310 } stringMatchTestData
[] =
5312 { _T("foobar"), _T("foo*"), 1 },
5313 { _T("foobar"), _T("*oo*"), 1 },
5314 { _T("foobar"), _T("*bar"), 1 },
5315 { _T("foobar"), _T("??????"), 1 },
5316 { _T("foobar"), _T("f??b*"), 1 },
5317 { _T("foobar"), _T("f?b*"), 0 },
5318 { _T("foobar"), _T("*goo*"), 0 },
5319 { _T("foobar"), _T("*foo"), 0 },
5320 { _T("foobarfoo"), _T("*foo"), 1 },
5321 { _T(""), _T("*"), 1 },
5322 { _T(""), _T("?"), 0 },
5325 for ( size_t n
= 0; n
< WXSIZEOF(stringMatchTestData
); n
++ )
5327 const StringMatchTestData
& data
= stringMatchTestData
[n
];
5328 bool matches
= wxString(data
.text
).Matches(data
.wildcard
);
5329 wxPrintf(_T("'%s' %s '%s' (%s)\n"),
5331 matches
? _T("matches") : _T("doesn't match"),
5333 matches
== data
.matches
? _T("ok") : _T("ERROR"));
5339 #endif // TEST_STRINGS
5341 // ----------------------------------------------------------------------------
5343 // ----------------------------------------------------------------------------
5345 #ifdef TEST_SNGLINST
5346 #include "wx/snglinst.h"
5347 #endif // TEST_SNGLINST
5349 int main(int argc
, char **argv
)
5351 wxInitializer initializer
;
5354 fprintf(stderr
, "Failed to initialize the wxWindows library, aborting.");
5359 #ifdef TEST_SNGLINST
5360 wxSingleInstanceChecker checker
;
5361 if ( checker
.Create(_T(".wxconsole.lock")) )
5363 if ( checker
.IsAnotherRunning() )
5365 wxPrintf(_T("Another instance of the program is running, exiting.\n"));
5370 // wait some time to give time to launch another instance
5371 wxPrintf(_T("Press \"Enter\" to continue..."));
5374 else // failed to create
5376 wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
5378 #endif // TEST_SNGLINST
5382 #endif // TEST_CHARSET
5385 TestCmdLineConvert();
5387 #if wxUSE_CMDLINE_PARSER
5388 static const wxCmdLineEntryDesc cmdLineDesc
[] =
5390 { wxCMD_LINE_SWITCH
, _T("h"), _T("help"), "show this help message",
5391 wxCMD_LINE_VAL_NONE
, wxCMD_LINE_OPTION_HELP
},
5392 { wxCMD_LINE_SWITCH
, "v", "verbose", "be verbose" },
5393 { wxCMD_LINE_SWITCH
, "q", "quiet", "be quiet" },
5395 { wxCMD_LINE_OPTION
, "o", "output", "output file" },
5396 { wxCMD_LINE_OPTION
, "i", "input", "input dir" },
5397 { wxCMD_LINE_OPTION
, "s", "size", "output block size",
5398 wxCMD_LINE_VAL_NUMBER
},
5399 { wxCMD_LINE_OPTION
, "d", "date", "output file date",
5400 wxCMD_LINE_VAL_DATE
},
5402 { wxCMD_LINE_PARAM
, NULL
, NULL
, "input file",
5403 wxCMD_LINE_VAL_STRING
, wxCMD_LINE_PARAM_MULTIPLE
},
5408 wxCmdLineParser
parser(cmdLineDesc
, argc
, argv
);
5410 parser
.AddOption("project_name", "", "full path to project file",
5411 wxCMD_LINE_VAL_STRING
,
5412 wxCMD_LINE_OPTION_MANDATORY
| wxCMD_LINE_NEEDS_SEPARATOR
);
5414 switch ( parser
.Parse() )
5417 wxLogMessage("Help was given, terminating.");
5421 ShowCmdLine(parser
);
5425 wxLogMessage("Syntax error detected, aborting.");
5428 #endif // wxUSE_CMDLINE_PARSER
5430 #endif // TEST_CMDLINE
5438 TestStringConstruction();
5441 TestStringTokenizer();
5442 TestStringReplace();
5448 #endif // TEST_STRINGS
5461 puts("*** Initially:");
5463 PrintArray("a1", a1
);
5465 wxArrayString
a2(a1
);
5466 PrintArray("a2", a2
);
5468 wxSortedArrayString
a3(a1
);
5469 PrintArray("a3", a3
);
5471 puts("*** After deleting a string from a1");
5474 PrintArray("a1", a1
);
5475 PrintArray("a2", a2
);
5476 PrintArray("a3", a3
);
5478 puts("*** After reassigning a1 to a2 and a3");
5480 PrintArray("a2", a2
);
5481 PrintArray("a3", a3
);
5483 puts("*** After sorting a1");
5485 PrintArray("a1", a1
);
5487 puts("*** After sorting a1 in reverse order");
5489 PrintArray("a1", a1
);
5491 puts("*** After sorting a1 by the string length");
5492 a1
.Sort(StringLenCompare
);
5493 PrintArray("a1", a1
);
5495 TestArrayOfObjects();
5501 #endif // TEST_ARRAYS
5511 #ifdef TEST_DLLLOADER
5513 #endif // TEST_DLLLOADER
5517 #endif // TEST_ENVIRON
5521 #endif // TEST_EXECUTE
5523 #ifdef TEST_FILECONF
5525 #endif // TEST_FILECONF
5533 #endif // TEST_LOCALE
5537 for ( size_t n
= 0; n
< 8000; n
++ )
5539 s
<< (char)('A' + (n
% 26));
5543 msg
.Printf("A very very long message: '%s', the end!\n", s
.c_str());
5545 // this one shouldn't be truncated
5548 // but this one will because log functions use fixed size buffer
5549 // (note that it doesn't need '\n' at the end neither - will be added
5551 wxLogMessage("A very very long message 2: '%s', the end!", s
.c_str());
5563 #ifdef TEST_FILENAME
5567 fn
.Assign("c:\\foo", "bar.baz");
5574 TestFileNameConstruction();
5575 TestFileNameMakeRelative();
5576 TestFileNameSplit();
5579 TestFileNameComparison();
5580 TestFileNameOperations();
5582 #endif // TEST_FILENAME
5584 #ifdef TEST_FILETIME
5587 #endif // TEST_FILETIME
5590 wxLog::AddTraceMask(FTP_TRACE_MASK
);
5591 if ( TestFtpConnect() )
5602 if ( TEST_INTERACTIVE
)
5603 TestFtpInteractive();
5605 //else: connecting to the FTP server failed
5611 #ifdef TEST_LONGLONG
5612 // seed pseudo random generator
5613 srand((unsigned)time(NULL
));
5622 TestMultiplication();
5625 TestLongLongConversion();
5626 TestBitOperations();
5627 TestLongLongComparison();
5628 TestLongLongPrint();
5630 #endif // TEST_LONGLONG
5638 #endif // TEST_HASHMAP
5641 wxLog::AddTraceMask(_T("mime"));
5649 TestMimeAssociate();
5652 #ifdef TEST_INFO_FUNCTIONS
5659 #endif // TEST_INFO_FUNCTIONS
5661 #ifdef TEST_PATHLIST
5663 #endif // TEST_PATHLIST
5671 #endif // TEST_REGCONF
5674 // TODO: write a real test using src/regex/tests file
5679 TestRegExSubmatch();
5680 TestRegExReplacement();
5682 if ( TEST_INTERACTIVE
)
5683 TestRegExInteractive();
5685 #endif // TEST_REGEX
5687 #ifdef TEST_REGISTRY
5689 TestRegistryAssociation();
5690 #endif // TEST_REGISTRY
5695 #endif // TEST_SOCKETS
5700 #endif // TEST_STREAMS
5703 int nCPUs
= wxThread::GetCPUCount();
5704 printf("This system has %d CPUs\n", nCPUs
);
5706 wxThread::SetConcurrency(nCPUs
);
5710 TestDetachedThreads();
5711 TestJoinableThreads();
5712 TestThreadSuspend();
5716 TestThreadConditions();
5717 #endif // TEST_THREADS
5721 #endif // TEST_TIMER
5723 #ifdef TEST_DATETIME
5736 TestTimeArithmetics();
5739 TestTimeSpanFormat();
5745 if ( TEST_INTERACTIVE
)
5746 TestDateTimeInteractive();
5747 #endif // TEST_DATETIME
5750 puts("Sleeping for 3 seconds... z-z-z-z-z...");
5752 #endif // TEST_USLEEP
5757 #endif // TEST_VCARD
5761 #endif // TEST_WCHAR
5764 TestZipStreamRead();
5765 TestZipFileSystem();
5769 TestZlibStreamWrite();
5770 TestZlibStreamRead();