git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: samples/console/console.cpp
	3	// Purpose: a sample console (as opposed to GUI) progam using wxWindows
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 04.10.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#include "wx/defs.h"
	21
	22	#if wxUSE_GUI
	23	#error "This sample can't be compiled in GUI mode."
	24	#endif // wxUSE_GUI
	25
	26	#include <stdio.h>
	27
	28	#include "wx/string.h"
	29	#include "wx/file.h"
	30	#include "wx/app.h"
	31
	32	// without this pragma, the stupid compiler precompiles #defines below so that
	33	// changing them doesn't "take place" later!
	34	#ifdef __VISUALC__
	35	#pragma hdrstop
	36	#endif
	37
	38	// ----------------------------------------------------------------------------
	39	// conditional compilation
	40	// ----------------------------------------------------------------------------
	41
	42	/*
	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.
	48	*/
	49
	50	// what to test (in alphabetic order)? uncomment the line below to do all tests
	51	//#define TEST_ALL
	52	#ifdef TEST_ALL
	53	#define TEST_ARRAYS
	54	#define TEST_CHARSET
	55	#define TEST_CMDLINE
	56	#define TEST_DATETIME
	57	#define TEST_DIR
	58	#define TEST_DLLLOADER
	59	#define TEST_ENVIRON
	60	#define TEST_EXECUTE
	61	#define TEST_FILE
	62	#define TEST_FILECONF
	63	#define TEST_FILENAME
	64	#define TEST_FILETIME
	65	#define TEST_FTP
	66	#define TEST_HASH
	67	#define TEST_HASHMAP
	68	#define TEST_INFO_FUNCTIONS
	69	#define TEST_LIST
	70	#define TEST_LOCALE
	71	#define TEST_LOG
	72	#define TEST_LONGLONG
	73	#define TEST_MIME
	74	#define TEST_PATHLIST
	75	#define TEST_ODBC
	76	#define TEST_PRINTF
	77	#define TEST_REGCONF
	78	#define TEST_REGEX
	79	#define TEST_REGISTRY
	80	#define TEST_SNGLINST
	81	#define TEST_SOCKETS
	82	#define TEST_STREAMS
	83	#define TEST_STRINGS
	84	#define TEST_TEXTSTREAM
	85	#define TEST_THREADS
	86	#define TEST_TIMER
	87	#define TEST_UNICODE
	88	// #define TEST_VCARD -- don't enable this (VZ)
	89	#define TEST_VOLUME
	90	#define TEST_WCHAR
	91	#define TEST_ZIP
	92	#define TEST_ZLIB
	93
	94	#undef TEST_ALL
	95	static const bool TEST_ALL = TRUE;
	96	#else
	97	#define TEST_TEXTSTREAM
	98
	99	static const bool TEST_ALL = FALSE;
	100	#endif
	101
	102	// some tests are interactive, define this to run them
	103	#ifdef TEST_INTERACTIVE
	104	#undef TEST_INTERACTIVE
	105
	106	static const bool TEST_INTERACTIVE = TRUE;
	107	#else
	108	static const bool TEST_INTERACTIVE = FALSE;
	109	#endif
	110
	111	// ----------------------------------------------------------------------------
	112	// test class for container objects
	113	// ----------------------------------------------------------------------------
	114
	115	#if defined(TEST_ARRAYS) \|\| defined(TEST_LIST)
	116
	117	class Bar // Foo is already taken in the hash test
	118	{
	119	public:
	120	Bar(const wxString& name) : m_name(name) { ms_bars++; }
	121	Bar(const Bar& bar) : m_name(bar.m_name) { ms_bars++; }
	122	~Bar() { ms_bars--; }
	123
	124	static size_t GetNumber() { return ms_bars; }
	125
	126	const wxChar *GetName() const { return m_name; }
	127
	128	private:
	129	wxString m_name;
	130
	131	static size_t ms_bars;
	132	};
	133
	134	size_t Bar::ms_bars = 0;
	135
	136	#endif // defined(TEST_ARRAYS) \|\| defined(TEST_LIST)
	137
	138	// ============================================================================
	139	// implementation
	140	// ============================================================================
	141
	142	// ----------------------------------------------------------------------------
	143	// helper functions
	144	// ----------------------------------------------------------------------------
	145
	146	#if defined(TEST_STRINGS) \|\| defined(TEST_SOCKETS)
	147
	148	// replace TABs with \t and CRs with \n
	149	static wxString MakePrintable(const wxChar *s)
	150	{
	151	wxString str(s);
	152	(void)str.Replace(_T("\t"), _T("\\t"));
	153	(void)str.Replace(_T("\n"), _T("\\n"));
	154	(void)str.Replace(_T("\r"), _T("\\r"));
	155
	156	return str;
	157	}
	158
	159	#endif // MakePrintable() is used
	160
	161	// ----------------------------------------------------------------------------
	162	// wxFontMapper::CharsetToEncoding
	163	// ----------------------------------------------------------------------------
	164
	165	#ifdef TEST_CHARSET
	166
	167	#include "wx/fontmap.h"
	168
	169	static void TestCharset()
	170	{
	171	static const wxChar *charsets[] =
	172	{
	173	// some vali charsets
	174	_T("us-ascii "),
	175	_T("iso8859-1 "),
	176	_T("iso-8859-12 "),
	177	_T("koi8-r "),
	178	_T("utf-7 "),
	179	_T("cp1250 "),
	180	_T("windows-1252"),
	181
	182	// and now some bogus ones
	183	_T(" "),
	184	_T("cp1249 "),
	185	_T("iso--8859-1 "),
	186	_T("iso-8859-19 "),
	187	};
	188
	189	for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
	190	{
	191	wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charsets[n]);
	192	wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
	193	charsets[n],
	194	wxFontMapper::Get()->GetEncodingName(enc).c_str(),
	195	wxFontMapper::Get()->GetEncodingDescription(enc).c_str());
	196	}
	197	}
	198
	199	#endif // TEST_CHARSET
	200
	201	// ----------------------------------------------------------------------------
	202	// wxCmdLineParser
	203	// ----------------------------------------------------------------------------
	204
	205	#ifdef TEST_CMDLINE
	206
	207	#include "wx/cmdline.h"
	208	#include "wx/datetime.h"
	209	#include "wx/log.h"
	210
	211	#if wxUSE_CMDLINE_PARSER
	212
	213	static void ShowCmdLine(const wxCmdLineParser& parser)
	214	{
	215	wxString s = _T("Input files: ");
	216
	217	size_t count = parser.GetParamCount();
	218	for ( size_t param = 0; param < count; param++ )
	219	{
	220	s << parser.GetParam(param) << ' ';
	221	}
	222
	223	s << '\n'
	224	<< _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
	225	<< _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
	226
	227	wxString strVal;
	228	long lVal;
	229	wxDateTime dt;
	230	if ( parser.Found(_T("o"), &strVal) )
	231	s << _T("Output file:\t") << strVal << '\n';
	232	if ( parser.Found(_T("i"), &strVal) )
	233	s << _T("Input dir:\t") << strVal << '\n';
	234	if ( parser.Found(_T("s"), &lVal) )
	235	s << _T("Size:\t") << lVal << '\n';
	236	if ( parser.Found(_T("d"), &dt) )
	237	s << _T("Date:\t") << dt.FormatISODate() << '\n';
	238	if ( parser.Found(_T("project_name"), &strVal) )
	239	s << _T("Project:\t") << strVal << '\n';
	240
	241	wxLogMessage(s);
	242	}
	243
	244	#endif // wxUSE_CMDLINE_PARSER
	245
	246	static void TestCmdLineConvert()
	247	{
	248	static const wxChar *cmdlines[] =
	249	{
	250	_T("arg1 arg2"),
	251	_T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
	252	_T("literal \\\" and \"\""),
	253	};
	254
	255	for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
	256	{
	257	const wxChar *cmdline = cmdlines[n];
	258	wxPrintf(_T("Parsing: %s\n"), cmdline);
	259	wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
	260
	261	size_t count = args.GetCount();
	262	wxPrintf(_T("\targc = %u\n"), count);
	263	for ( size_t arg = 0; arg < count; arg++ )
	264	{
	265	wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
	266	}
	267	}
	268	}
	269
	270	#endif // TEST_CMDLINE
	271
	272	// ----------------------------------------------------------------------------
	273	// wxDir
	274	// ----------------------------------------------------------------------------
	275
	276	#ifdef TEST_DIR
	277
	278	#include "wx/dir.h"
	279
	280	#ifdef __UNIX__
	281	static const wxChar *ROOTDIR = _T("/");
	282	static const wxChar *TESTDIR = _T("/usr");
	283	#elif defined(__WXMSW__)
	284	static const wxChar *ROOTDIR = _T("c:\\");
	285	static const wxChar *TESTDIR = _T("d:\\");
	286	#else
	287	#error "don't know where the root directory is"
	288	#endif
	289
	290	static void TestDirEnumHelper(wxDir& dir,
	291	int flags = wxDIR_DEFAULT,
	292	const wxString& filespec = wxEmptyString)
	293	{
	294	wxString filename;
	295
	296	if ( !dir.IsOpened() )
	297	return;
	298
	299	bool cont = dir.GetFirst(&filename, filespec, flags);
	300	while ( cont )
	301	{
	302	wxPrintf(_T("\t%s\n"), filename.c_str());
	303
	304	cont = dir.GetNext(&filename);
	305	}
	306
	307	wxPuts(_T(""));
	308	}
	309
	310	static void TestDirEnum()
	311	{
	312	wxPuts(_T("* Testing wxDir::GetFirst/GetNext *"));
	313
	314	wxString cwd = wxGetCwd();
	315	if ( !wxDir::Exists(cwd) )
	316	{
	317	wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
	318	return;
	319	}
	320
	321	wxDir dir(cwd);
	322	if ( !dir.IsOpened() )
	323	{
	324	wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
	325	return;
	326	}
	327
	328	wxPuts(_T("Enumerating everything in current directory:"));
	329	TestDirEnumHelper(dir);
	330
	331	wxPuts(_T("Enumerating really everything in current directory:"));
	332	TestDirEnumHelper(dir, wxDIR_DEFAULT \| wxDIR_DOTDOT);
	333
	334	wxPuts(_T("Enumerating object files in current directory:"));
	335	TestDirEnumHelper(dir, wxDIR_DEFAULT, ".o");
	336
	337	wxPuts(_T("Enumerating directories in current directory:"));
	338	TestDirEnumHelper(dir, wxDIR_DIRS);
	339
	340	wxPuts(_T("Enumerating files in current directory:"));
	341	TestDirEnumHelper(dir, wxDIR_FILES);
	342
	343	wxPuts(_T("Enumerating files including hidden in current directory:"));
	344	TestDirEnumHelper(dir, wxDIR_FILES \| wxDIR_HIDDEN);
	345
	346	dir.Open(ROOTDIR);
	347
	348	wxPuts(_T("Enumerating everything in root directory:"));
	349	TestDirEnumHelper(dir, wxDIR_DEFAULT);
	350
	351	wxPuts(_T("Enumerating directories in root directory:"));
	352	TestDirEnumHelper(dir, wxDIR_DIRS);
	353
	354	wxPuts(_T("Enumerating files in root directory:"));
	355	TestDirEnumHelper(dir, wxDIR_FILES);
	356
	357	wxPuts(_T("Enumerating files including hidden in root directory:"));
	358	TestDirEnumHelper(dir, wxDIR_FILES \| wxDIR_HIDDEN);
	359
	360	wxPuts(_T("Enumerating files in non existing directory:"));
	361	wxDir dirNo("nosuchdir");
	362	TestDirEnumHelper(dirNo);
	363	}
	364
	365	class DirPrintTraverser : public wxDirTraverser
	366	{
	367	public:
	368	virtual wxDirTraverseResult OnFile(const wxString& filename)
	369	{
	370	return wxDIR_CONTINUE;
	371	}
	372
	373	virtual wxDirTraverseResult OnDir(const wxString& dirname)
	374	{
	375	wxString path, name, ext;
	376	wxSplitPath(dirname, &path, &name, &ext);
	377
	378	if ( !ext.empty() )
	379	name << _T('.') << ext;
	380
	381	wxString indent;
	382	for ( const wxChar p = path.c_str(); p; p++ )
	383	{
	384	if ( wxIsPathSeparator(*p) )
	385	indent += _T(" ");
	386	}
	387
	388	wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
	389
	390	return wxDIR_CONTINUE;
	391	}
	392	};
	393
	394	static void TestDirTraverse()
	395	{
	396	wxPuts(_T("* Testing wxDir::Traverse() *"));
	397
	398	// enum all files
	399	wxArrayString files;
	400	size_t n = wxDir::GetAllFiles(TESTDIR, &files);
	401	wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
	402	if ( n > 1 )
	403	{
	404	wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
	405	wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
	406	}
	407
	408	// enum again with custom traverser
	409	wxDir dir(TESTDIR);
	410	DirPrintTraverser traverser;
	411	dir.Traverse(traverser, _T(""), wxDIR_DIRS \| wxDIR_HIDDEN);
	412	}
	413
	414	static void TestDirExists()
	415	{
	416	wxPuts(_T("* Testing wxDir::Exists() *"));
	417
	418	static const wxChar *dirnames[] =
	419	{
	420	_T("."),
	421	#if defined(__WXMSW__)
	422	_T("c:"),
	423	_T("c:\\"),
	424	_T("\\\\share\\file"),
	425	_T("c:\\dos"),
	426	_T("c:\\dos\\"),
	427	_T("c:\\dos\\\\"),
	428	_T("c:\\autoexec.bat"),
	429	#elif defined(__UNIX__)
	430	_T("/"),
	431	_T("//"),
	432	_T("/usr/bin"),
	433	_T("/usr//bin"),
	434	_T("/usr///bin"),
	435	#endif
	436	};
	437
	438	for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
	439	{
	440	wxPrintf(_T("%-40s: %s\n"),
	441	dirnames[n],
	442	wxDir::Exists(dirnames[n]) ? _T("exists")
	443	: _T("doesn't exist"));
	444	}
	445	}
	446
	447	#endif // TEST_DIR
	448
	449	// ----------------------------------------------------------------------------
	450	// wxDllLoader
	451	// ----------------------------------------------------------------------------
	452
	453	#ifdef TEST_DLLLOADER
	454
	455	#include "wx/dynlib.h"
	456
	457	static void TestDllLoad()
	458	{
	459	#if defined(__WXMSW__)
	460	static const wxChar *LIB_NAME = _T("kernel32.dll");
	461	static const wxChar *FUNC_NAME = _T("lstrlenA");
	462	#elif defined(__UNIX__)
	463	// weird: using just libc.so does not work!
	464	static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
	465	static const wxChar *FUNC_NAME = _T("strlen");
	466	#else
	467	#error "don't know how to test wxDllLoader on this platform"
	468	#endif
	469
	470	wxPuts(_T("* testing wxDllLoader *\n"));
	471
	472	wxDynamicLibrary lib(LIB_NAME);
	473	if ( !lib.IsLoaded() )
	474	{
	475	wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
	476	}
	477	else
	478	{
	479	typedef int (wxStrlenType)(const char );
	480	wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
	481	if ( !pfnStrlen )
	482	{
	483	wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
	484	FUNC_NAME, LIB_NAME);
	485	}
	486	else
	487	{
	488	if ( pfnStrlen("foo") != 3 )
	489	{
	490	wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
	491	}
	492	else
	493	{
	494	wxPuts(_T("... ok"));
	495	}
	496	}
	497	}
	498	}
	499
	500	#endif // TEST_DLLLOADER
	501
	502	// ----------------------------------------------------------------------------
	503	// wxGet/SetEnv
	504	// ----------------------------------------------------------------------------
	505
	506	#ifdef TEST_ENVIRON
	507
	508	#include "wx/utils.h"
	509
	510	static wxString MyGetEnv(const wxString& var)
	511	{
	512	wxString val;
	513	if ( !wxGetEnv(var, &val) )
	514	val = _T("<empty>");
	515	else
	516	val = wxString(_T('\'')) + val + _T('\'');
	517
	518	return val;
	519	}
	520
	521	static void TestEnvironment()
	522	{
	523	const wxChar *var = _T("wxTestVar");
	524
	525	wxPuts(_T("* testing environment access functions *"));
	526
	527	wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	528	wxSetEnv(var, _T("value for wxTestVar"));
	529	wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	530	wxSetEnv(var, _T("another value"));
	531	wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	532	wxUnsetEnv(var);
	533	wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	534	wxPrintf(_T("PATH = %s\n"), MyGetEnv(_T("PATH")).c_str());
	535	}
	536
	537	#endif // TEST_ENVIRON
	538
	539	// ----------------------------------------------------------------------------
	540	// wxExecute
	541	// ----------------------------------------------------------------------------
	542
	543	#ifdef TEST_EXECUTE
	544
	545	#include "wx/utils.h"
	546
	547	static void TestExecute()
	548	{
	549	wxPuts(_T("* testing wxExecute *"));
	550
	551	#ifdef __UNIX__
	552	#define COMMAND "cat -n ../../Makefile" // "echo hi"
	553	#define SHELL_COMMAND "echo hi from shell"
	554	#define REDIRECT_COMMAND COMMAND // "date"
	555	#elif defined(__WXMSW__)
	556	#define COMMAND "command.com /c echo hi"
	557	#define SHELL_COMMAND "echo hi"
	558	#define REDIRECT_COMMAND COMMAND
	559	#else
	560	#error "no command to exec"
	561	#endif // OS
	562
	563	wxPrintf(_T("Testing wxShell: "));
	564	fflush(stdout);
	565	if ( wxShell(SHELL_COMMAND) )
	566	wxPuts(_T("Ok."));
	567	else
	568	wxPuts(_T("ERROR."));
	569
	570	wxPrintf(_T("Testing wxExecute: "));
	571	fflush(stdout);
	572	if ( wxExecute(COMMAND, TRUE /* sync */) == 0 )
	573	wxPuts(_T("Ok."));
	574	else
	575	wxPuts(_T("ERROR."));
	576
	577	#if 0 // no, it doesn't work (yet?)
	578	wxPrintf(_T("Testing async wxExecute: "));
	579	fflush(stdout);
	580	if ( wxExecute(COMMAND) != 0 )
	581	wxPuts(_T("Ok (command launched)."));
	582	else
	583	wxPuts(_T("ERROR."));
	584	#endif // 0
	585
	586	wxPrintf(_T("Testing wxExecute with redirection:\n"));
	587	wxArrayString output;
	588	if ( wxExecute(REDIRECT_COMMAND, output) != 0 )
	589	{
	590	wxPuts(_T("ERROR."));
	591	}
	592	else
	593	{
	594	size_t count = output.GetCount();
	595	for ( size_t n = 0; n < count; n++ )
	596	{
	597	wxPrintf(_T("\t%s\n"), output[n].c_str());
	598	}
	599
	600	wxPuts(_T("Ok."));
	601	}
	602	}
	603
	604	#endif // TEST_EXECUTE
	605
	606	// ----------------------------------------------------------------------------
	607	// file
	608	// ----------------------------------------------------------------------------
	609
	610	#ifdef TEST_FILE
	611
	612	#include "wx/file.h"
	613	#include "wx/ffile.h"
	614	#include "wx/textfile.h"
	615
	616	static void TestFileRead()
	617	{
	618	wxPuts(_T("* wxFile read test *"));
	619
	620	wxFile file(_T("testdata.fc"));
	621	if ( file.IsOpened() )
	622	{
	623	wxPrintf(_T("File length: %lu\n"), file.Length());
	624
	625	wxPuts(_T("File dump:\n----------"));
	626
	627	static const off_t len = 1024;
	628	wxChar buf[len];
	629	for ( ;; )
	630	{
	631	off_t nRead = file.Read(buf, len);
	632	if ( nRead == wxInvalidOffset )
	633	{
	634	wxPrintf(_T("Failed to read the file."));
	635	break;
	636	}
	637
	638	fwrite(buf, nRead, 1, stdout);
	639
	640	if ( nRead < len )
	641	break;
	642	}
	643
	644	wxPuts(_T("----------"));
	645	}
	646	else
	647	{
	648	wxPrintf(_T("ERROR: can't open test file.\n"));
	649	}
	650
	651	wxPuts(_T(""));
	652	}
	653
	654	static void TestTextFileRead()
	655	{
	656	wxPuts(_T("* wxTextFile read test *"));
	657
	658	wxTextFile file(_T("testdata.fc"));
	659	if ( file.Open() )
	660	{
	661	wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
	662	wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
	663
	664	wxString s;
	665
	666	wxPuts(_T("\nDumping the entire file:"));
	667	for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
	668	{
	669	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	670	}
	671	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	672
	673	wxPuts(_T("\nAnd now backwards:"));
	674	for ( s = file.GetLastLine();
	675	file.GetCurrentLine() != 0;
	676	s = file.GetPrevLine() )
	677	{
	678	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	679	}
	680	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	681	}
	682	else
	683	{
	684	wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
	685	}
	686
	687	wxPuts(_T(""));
	688	}
	689
	690	static void TestFileCopy()
	691	{
	692	wxPuts(_T("* Testing wxCopyFile *"));
	693
	694	static const wxChar *filename1 = _T("testdata.fc");
	695	static const wxChar *filename2 = _T("test2");
	696	if ( !wxCopyFile(filename1, filename2) )
	697	{
	698	wxPuts(_T("ERROR: failed to copy file"));
	699	}
	700	else
	701	{
	702	wxFFile f1(filename1, "rb"),
	703	f2(filename2, "rb");
	704
	705	if ( !f1.IsOpened() \|\| !f2.IsOpened() )
	706	{
	707	wxPuts(_T("ERROR: failed to open file(s)"));
	708	}
	709	else
	710	{
	711	wxString s1, s2;
	712	if ( !f1.ReadAll(&s1) \|\| !f2.ReadAll(&s2) )
	713	{
	714	wxPuts(_T("ERROR: failed to read file(s)"));
	715	}
	716	else
	717	{
	718	if ( (s1.length() != s2.length()) \|\|
	719	(memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
	720	{
	721	wxPuts(_T("ERROR: copy error!"));
	722	}
	723	else
	724	{
	725	wxPuts(_T("File was copied ok."));
	726	}
	727	}
	728	}
	729	}
	730
	731	if ( !wxRemoveFile(filename2) )
	732	{
	733	wxPuts(_T("ERROR: failed to remove the file"));
	734	}
	735
	736	wxPuts(_T(""));
	737	}
	738
	739	#endif // TEST_FILE
	740
	741	// ----------------------------------------------------------------------------
	742	// wxFileConfig
	743	// ----------------------------------------------------------------------------
	744
	745	#ifdef TEST_FILECONF
	746
	747	#include "wx/confbase.h"
	748	#include "wx/fileconf.h"
	749
	750	static const struct FileConfTestData
	751	{
	752	const wxChar *name; // value name
	753	const wxChar *value; // the value from the file
	754	} fcTestData[] =
	755	{
	756	{ _T("value1"), _T("one") },
	757	{ _T("value2"), _T("two") },
	758	{ _T("novalue"), _T("default") },
	759	};
	760
	761	static void TestFileConfRead()
	762	{
	763	wxPuts(_T("* testing wxFileConfig loading/reading *"));
	764
	765	wxFileConfig fileconf(_T("test"), wxEmptyString,
	766	_T("testdata.fc"), wxEmptyString,
	767	wxCONFIG_USE_RELATIVE_PATH);
	768
	769	// test simple reading
	770	wxPuts(_T("\nReading config file:"));
	771	wxString defValue(_T("default")), value;
	772	for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
	773	{
	774	const FileConfTestData& data = fcTestData[n];
	775	value = fileconf.Read(data.name, defValue);
	776	wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
	777	if ( value == data.value )
	778	{
	779	wxPuts(_T("(ok)"));
	780	}
	781	else
	782	{
	783	wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
	784	}
	785	}
	786
	787	// test enumerating the entries
	788	wxPuts(_T("\nEnumerating all root entries:"));
	789	long dummy;
	790	wxString name;
	791	bool cont = fileconf.GetFirstEntry(name, dummy);
	792	while ( cont )
	793	{
	794	wxPrintf(_T("\t%s = %s\n"),
	795	name.c_str(),
	796	fileconf.Read(name.c_str(), _T("ERROR")).c_str());
	797
	798	cont = fileconf.GetNextEntry(name, dummy);
	799	}
	800	}
	801
	802	#endif // TEST_FILECONF
	803
	804	// ----------------------------------------------------------------------------
	805	// wxFileName
	806	// ----------------------------------------------------------------------------
	807
	808	#ifdef TEST_FILENAME
	809
	810	#include "wx/filename.h"
	811
	812	static void DumpFileName(const wxFileName& fn)
	813	{
	814	wxString full = fn.GetFullPath();
	815
	816	wxString vol, path, name, ext;
	817	wxFileName::SplitPath(full, &vol, &path, &name, &ext);
	818
	819	wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
	820	full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
	821
	822	wxFileName::SplitPath(full, &path, &name, &ext);
	823	wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
	824	path.c_str(), name.c_str(), ext.c_str());
	825
	826	wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
	827	wxPrintf(_T("with volume: \t'%s'\n"),
	828	fn.GetPath(wxPATH_GET_VOLUME).c_str());
	829	wxPrintf(_T("with separator:\t'%s'\n"),
	830	fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
	831	wxPrintf(_T("with both: \t'%s'\n"),
	832	fn.GetPath(wxPATH_GET_SEPARATOR \| wxPATH_GET_VOLUME).c_str());
	833
	834	wxPuts(_T("The directories in the path are:"));
	835	wxArrayString dirs = fn.GetDirs();
	836	size_t count = dirs.GetCount();
	837	for ( size_t n = 0; n < count; n++ )
	838	{
	839	wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
	840	}
	841	}
	842
	843	static struct FileNameInfo
	844	{
	845	const wxChar *fullname;
	846	const wxChar *volume;
	847	const wxChar *path;
	848	const wxChar *name;
	849	const wxChar *ext;
	850	bool isAbsolute;
	851	wxPathFormat format;
	852	} filenames[] =
	853	{
	854	// Unix file names
	855	{ _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), TRUE, wxPATH_UNIX },
	856	{ _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), TRUE, wxPATH_UNIX },
	857	{ _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), TRUE, wxPATH_UNIX },
	858	{ _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), FALSE, wxPATH_UNIX },
	859	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
	860	{ _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), TRUE, wxPATH_UNIX },
	861	{ _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), TRUE, wxPATH_UNIX },
	862	{ _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), FALSE, wxPATH_UNIX },
	863	{ _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), TRUE, wxPATH_UNIX },
	864
	865	// Windows file names
	866	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
	867	{ _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
	868	{ _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), FALSE, wxPATH_DOS },
	869	{ _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
	870	{ _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), TRUE, wxPATH_DOS },
	871	{ _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
	872	{ _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
	873
	874	// wxFileName support for Mac file names is broken currently
	875	#if 0
	876	// Mac file names
	877	{ _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
	878	{ _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
	879	{ _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), TRUE, wxPATH_MAC },
	880	{ _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), FALSE, wxPATH_MAC },
	881	{ _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
	882	{ _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
	883	#endif // 0
	884
	885	// VMS file names
	886	{ _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE, wxPATH_VMS },
	887	{ _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), FALSE, wxPATH_VMS },
	888	};
	889
	890	static void TestFileNameConstruction()
	891	{
	892	wxPuts(_T("* testing wxFileName construction *"));
	893
	894	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	895	{
	896	const FileNameInfo& fni = filenames[n];
	897
	898	wxFileName fn(fni.fullname, fni.format);
	899
	900	wxString fullname = fn.GetFullPath(fni.format);
	901	if ( fullname != fni.fullname )
	902	{
	903	wxPrintf(_T("ERROR: fullname should be '%s'\n"), fni.fullname);
	904	}
	905
	906	bool isAbsolute = fn.IsAbsolute(fni.format);
	907	wxPrintf(_T("'%s' is %s (%s)\n\t"),
	908	fullname.c_str(),
	909	isAbsolute ? "absolute" : "relative",
	910	isAbsolute == fni.isAbsolute ? "ok" : "ERROR");
	911
	912	if ( !fn.Normalize(wxPATH_NORM_ALL, _T(""), fni.format) )
	913	{
	914	wxPuts(_T("ERROR (couldn't be normalized)"));
	915	}
	916	else
	917	{
	918	wxPrintf(_T("normalized: '%s'\n"), fn.GetFullPath(fni.format).c_str());
	919	}
	920	}
	921
	922	wxPuts(_T(""));
	923	}
	924
	925	static void TestFileNameSplit()
	926	{
	927	wxPuts(_T("* testing wxFileName splitting *"));
	928
	929	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	930	{
	931	const FileNameInfo& fni = filenames[n];
	932	wxString volume, path, name, ext;
	933	wxFileName::SplitPath(fni.fullname,
	934	&volume, &path, &name, &ext, fni.format);
	935
	936	wxPrintf(_T("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'"),
	937	fni.fullname,
	938	volume.c_str(), path.c_str(), name.c_str(), ext.c_str());
	939
	940	if ( volume != fni.volume )
	941	wxPrintf(_T(" (ERROR: volume = '%s')"), fni.volume);
	942	if ( path != fni.path )
	943	wxPrintf(_T(" (ERROR: path = '%s')"), fni.path);
	944	if ( name != fni.name )
	945	wxPrintf(_T(" (ERROR: name = '%s')"), fni.name);
	946	if ( ext != fni.ext )
	947	wxPrintf(_T(" (ERROR: ext = '%s')"), fni.ext);
	948
	949	wxPuts(_T(""));
	950	}
	951	}
	952
	953	static void TestFileNameTemp()
	954	{
	955	wxPuts(_T("* testing wxFileName temp file creation *"));
	956
	957	static const wxChar *tmpprefixes[] =
	958	{
	959	_T(""),
	960	_T("foo"),
	961	_T(".."),
	962	_T("../bar"),
	963	#ifdef __UNIX__
	964	_T("/tmp/foo"),
	965	_T("/tmp/foo/bar"), // this one must be an error
	966	#endif // __UNIX__
	967	};
	968
	969	for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
	970	{
	971	wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
	972	if ( path.empty() )
	973	{
	974	// "error" is not in upper case because it may be ok
	975	wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
	976	}
	977	else
	978	{
	979	wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
	980	tmpprefixes[n], path.c_str());
	981
	982	if ( !wxRemoveFile(path) )
	983	{
	984	wxLogWarning(_T("Failed to remove temp file '%s'"),
	985	path.c_str());
	986	}
	987	}
	988	}
	989	}
	990
	991	static void TestFileNameMakeRelative()
	992	{
	993	wxPuts(_T("* testing wxFileName::MakeRelativeTo() *"));
	994
	995	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	996	{
	997	const FileNameInfo& fni = filenames[n];
	998
	999	wxFileName fn(fni.fullname, fni.format);
	1000
	1001	// choose the base dir of the same format
	1002	wxString base;
	1003	switch ( fni.format )
	1004	{
	1005	case wxPATH_UNIX:
	1006	base = "/usr/bin/";
	1007	break;
	1008
	1009	case wxPATH_DOS:
	1010	base = "c:\\";
	1011	break;
	1012
	1013	case wxPATH_MAC:
	1014	case wxPATH_VMS:
	1015	// TODO: I don't know how this is supposed to work there
	1016	continue;
	1017
	1018	case wxPATH_NATIVE: // make gcc happy
	1019	default:
	1020	wxFAIL_MSG( "unexpected path format" );
	1021	}
	1022
	1023	wxPrintf(_T("'%s' relative to '%s': "),
	1024	fn.GetFullPath(fni.format).c_str(), base.c_str());
	1025
	1026	if ( !fn.MakeRelativeTo(base, fni.format) )
	1027	{
	1028	wxPuts(_T("unchanged"));
	1029	}
	1030	else
	1031	{
	1032	wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
	1033	}
	1034	}
	1035	}
	1036
	1037	static void TestFileNameComparison()
	1038	{
	1039	// TODO!
	1040	}
	1041
	1042	static void TestFileNameOperations()
	1043	{
	1044	// TODO!
	1045	}
	1046
	1047	static void TestFileNameCwd()
	1048	{
	1049	// TODO!
	1050	}
	1051
	1052	#endif // TEST_FILENAME
	1053
	1054	// ----------------------------------------------------------------------------
	1055	// wxFileName time functions
	1056	// ----------------------------------------------------------------------------
	1057
	1058	#ifdef TEST_FILETIME
	1059
	1060	#include <wx/filename.h>
	1061	#include <wx/datetime.h>
	1062
	1063	static void TestFileGetTimes()
	1064	{
	1065	wxFileName fn(_T("testdata.fc"));
	1066
	1067	wxDateTime dtAccess, dtMod, dtCreate;
	1068	if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
	1069	{
	1070	wxPrintf(_T("ERROR: GetTimes() failed.\n"));
	1071	}
	1072	else
	1073	{
	1074	static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
	1075
	1076	wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
	1077	wxPrintf(_T("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
	1078	wxPrintf(_T("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
	1079	wxPrintf(_T("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
	1080	}
	1081	}
	1082
	1083	static void TestFileSetTimes()
	1084	{
	1085	wxFileName fn(_T("testdata.fc"));
	1086
	1087	if ( !fn.Touch() )
	1088	{
	1089	wxPrintf(_T("ERROR: Touch() failed.\n"));
	1090	}
	1091	}
	1092
	1093	#endif // TEST_FILETIME
	1094
	1095	// ----------------------------------------------------------------------------
	1096	// wxHashTable
	1097	// ----------------------------------------------------------------------------
	1098
	1099	#ifdef TEST_HASH
	1100
	1101	#include "wx/hash.h"
	1102
	1103	struct Foo
	1104	{
	1105	Foo(int n_) { n = n_; count++; }
	1106	~Foo() { count--; }
	1107
	1108	int n;
	1109
	1110	static size_t count;
	1111	};
	1112
	1113	size_t Foo::count = 0;
	1114
	1115	WX_DECLARE_LIST(Foo, wxListFoos);
	1116	WX_DECLARE_HASH(Foo, wxListFoos, wxHashFoos);
	1117
	1118	#include "wx/listimpl.cpp"
	1119
	1120	WX_DEFINE_LIST(wxListFoos);
	1121
	1122	static void TestHash()
	1123	{
	1124	wxPuts(_T("* Testing wxHashTable *\n"));
	1125
	1126	{
	1127	wxHashFoos hash;
	1128	hash.DeleteContents(TRUE);
	1129
	1130	wxPrintf(_T("Hash created: %u foos in hash, %u foos totally\n"),
	1131	hash.GetCount(), Foo::count);
	1132
	1133	static const int hashTestData[] =
	1134	{
	1135	0, 1, 17, -2, 2, 4, -4, 345, 3, 3, 2, 1,
	1136	};
	1137
	1138	size_t n;
	1139	for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
	1140	{
	1141	hash.Put(hashTestData[n], n, new Foo(n));
	1142	}
	1143
	1144	wxPrintf(_T("Hash filled: %u foos in hash, %u foos totally\n"),
	1145	hash.GetCount(), Foo::count);
	1146
	1147	wxPuts(_T("Hash access test:"));
	1148	for ( n = 0; n < WXSIZEOF(hashTestData); n++ )
	1149	{
	1150	wxPrintf(_T("\tGetting element with key %d, value %d: "),
	1151	hashTestData[n], n);
	1152	Foo *foo = hash.Get(hashTestData[n], n);
	1153	if ( !foo )
	1154	{
	1155	wxPrintf(_T("ERROR, not found.\n"));
	1156	}
	1157	else
	1158	{
	1159	wxPrintf(_T("%d (%s)\n"), foo->n,
	1160	(size_t)foo->n == n ? "ok" : "ERROR");
	1161	}
	1162	}
	1163
	1164	wxPrintf(_T("\nTrying to get an element not in hash: "));
	1165
	1166	if ( hash.Get(1234) \|\| hash.Get(1, 0) )
	1167	{
	1168	wxPuts(_T("ERROR: found!"));
	1169	}
	1170	else
	1171	{
	1172	wxPuts(_T("ok (not found)"));
	1173	}
	1174	}
	1175
	1176	wxPrintf(_T("Hash destroyed: %u foos left\n"), Foo::count);
	1177	}
	1178
	1179	#endif // TEST_HASH
	1180
	1181	// ----------------------------------------------------------------------------
	1182	// wxHashMap
	1183	// ----------------------------------------------------------------------------
	1184
	1185	#ifdef TEST_HASHMAP
	1186
	1187	#include "wx/hashmap.h"
	1188
	1189	// test compilation of basic map types
	1190	WX_DECLARE_HASH_MAP( int, int, wxPointerHash, wxPointerEqual, myPtrHashMap );
	1191	WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
	1192	WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
	1193	myUnsignedHashMap );
	1194	WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
	1195	myTestHashMap1 );
	1196	WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
	1197	myTestHashMap2 );
	1198	WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
	1199	myTestHashMap3 );
	1200	WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
	1201	myTestHashMap4 );
	1202
	1203	// same as:
	1204	// WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
	1205	// myStringHashMap );
	1206	WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
	1207
	1208	typedef myStringHashMap::iterator Itor;
	1209
	1210	static void TestHashMap()
	1211	{
	1212	wxPuts(_T("* Testing wxHashMap *\n"));
	1213	myStringHashMap sh(0); // as small as possible
	1214	wxString buf;
	1215	size_t i;
	1216	const size_t count = 10000;
	1217
	1218	// init with some data
	1219	for( i = 0; i < count; ++i )
	1220	{
	1221	buf.Printf(wxT("%d"), i );
	1222	sh[buf] = wxT("A") + buf + wxT("C");
	1223	}
	1224
	1225	// test that insertion worked
	1226	if( sh.size() != count )
	1227	{
	1228	wxPrintf(_T("* ERROR: %u ELEMENTS, SHOULD BE %u *\n"), sh.size(), count);
	1229	}
	1230
	1231	for( i = 0; i < count; ++i )
	1232	{
	1233	buf.Printf(wxT("%d"), i );
	1234	if( sh[buf] != wxT("A") + buf + wxT("C") )
	1235	{
	1236	wxPrintf(_T("* ERROR INSERTION BROKEN! STOPPING NOW! *\n"));
	1237	return;
	1238	}
	1239	}
	1240
	1241	// check that iterators work
	1242	Itor it;
	1243	for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
	1244	{
	1245	if( i == count )
	1246	{
	1247	wxPrintf(_T("* ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! *\n"));
	1248	return;
	1249	}
	1250
	1251	if( it->second != sh[it->first] )
	1252	{
	1253	wxPrintf(_T("* ERROR ITERATORS BROKEN! STOPPING NOW! *\n"));
	1254	return;
	1255	}
	1256	}
	1257
	1258	if( sh.size() != i )
	1259	{
	1260	wxPrintf(_T("* ERROR: %u ELEMENTS ITERATED, SHOULD BE %u *\n"), i, count);
	1261	}
	1262
	1263	// test copy ctor, assignment operator
	1264	myStringHashMap h1( sh ), h2( 0 );
	1265	h2 = sh;
	1266
	1267	for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
	1268	{
	1269	if( h1[it->first] != it->second )
	1270	{
	1271	wxPrintf(_T("* ERROR: COPY CTOR BROKEN %s *\n"), it->first.c_str());
	1272	}
	1273
	1274	if( h2[it->first] != it->second )
	1275	{
	1276	wxPrintf(_T("* ERROR: OPERATOR= BROKEN %s *\n"), it->first.c_str());
	1277	}
	1278	}
	1279
	1280	// other tests
	1281	for( i = 0; i < count; ++i )
	1282	{
	1283	buf.Printf(wxT("%d"), i );
	1284	size_t sz = sh.size();
	1285
	1286	// test find() and erase(it)
	1287	if( i < 100 )
	1288	{
	1289	it = sh.find( buf );
	1290	if( it != sh.end() )
	1291	{
	1292	sh.erase( it );
	1293
	1294	if( sh.find( buf ) != sh.end() )
	1295	{
	1296	wxPrintf(_T("* ERROR: FOUND DELETED ELEMENT %u *\n"), i);
	1297	}
	1298	}
	1299	else
	1300	wxPrintf(_T("* ERROR: CANT FIND ELEMENT %u *\n"), i);
	1301	}
	1302	else
	1303	// test erase(key)
	1304	{
	1305	size_t c = sh.erase( buf );
	1306	if( c != 1 )
	1307	wxPrintf(_T("* ERROR: SHOULD RETURN 1 *\n"));
	1308
	1309	if( sh.find( buf ) != sh.end() )
	1310	{
	1311	wxPrintf(_T("* ERROR: FOUND DELETED ELEMENT %u *\n"), i);
	1312	}
	1313	}
	1314
	1315	// count should decrease
	1316	if( sh.size() != sz - 1 )
	1317	{
	1318	wxPrintf(_T("* ERROR: COUNT DID NOT DECREASE *\n"));
	1319	}
	1320	}
	1321
	1322	wxPrintf(_T("* Finished testing wxHashMap *\n"));
	1323	}
	1324
	1325	#endif // TEST_HASHMAP
	1326
	1327	// ----------------------------------------------------------------------------
	1328	// wxList
	1329	// ----------------------------------------------------------------------------
	1330
	1331	#ifdef TEST_LIST
	1332
	1333	#include "wx/list.h"
	1334
	1335	WX_DECLARE_LIST(Bar, wxListBars);
	1336	#include "wx/listimpl.cpp"
	1337	WX_DEFINE_LIST(wxListBars);
	1338
	1339	static void TestListCtor()
	1340	{
	1341	wxPuts(_T("* Testing wxList construction *\n"));
	1342
	1343	{
	1344	wxListBars list1;
	1345	list1.Append(new Bar(_T("first")));
	1346	list1.Append(new Bar(_T("second")));
	1347
	1348	wxPrintf(_T("After 1st list creation: %u objects in the list, %u objects total.\n"),
	1349	list1.GetCount(), Bar::GetNumber());
	1350
	1351	wxListBars list2;
	1352	list2 = list1;
	1353
	1354	wxPrintf(_T("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n"),
	1355	list1.GetCount(), list2.GetCount(), Bar::GetNumber());
	1356
	1357	list1.DeleteContents(TRUE);
	1358	}
	1359
	1360	wxPrintf(_T("After list destruction: %u objects left.\n"), Bar::GetNumber());
	1361	}
	1362
	1363	#endif // TEST_LIST
	1364
	1365	// ----------------------------------------------------------------------------
	1366	// wxLocale
	1367	// ----------------------------------------------------------------------------
	1368
	1369	#ifdef TEST_LOCALE
	1370
	1371	#include "wx/intl.h"
	1372	#include "wx/utils.h" // for wxSetEnv
	1373
	1374	static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
	1375
	1376	// find the name of the language from its value
	1377	static const wxChar *GetLangName(int lang)
	1378	{
	1379	static const wxChar *languageNames[] =
	1380	{
	1381	_T("DEFAULT"),
	1382	_T("UNKNOWN"),
	1383	_T("ABKHAZIAN"),
	1384	_T("AFAR"),
	1385	_T("AFRIKAANS"),
	1386	_T("ALBANIAN"),
	1387	_T("AMHARIC"),
	1388	_T("ARABIC"),
	1389	_T("ARABIC_ALGERIA"),
	1390	_T("ARABIC_BAHRAIN"),
	1391	_T("ARABIC_EGYPT"),
	1392	_T("ARABIC_IRAQ"),
	1393	_T("ARABIC_JORDAN"),
	1394	_T("ARABIC_KUWAIT"),
	1395	_T("ARABIC_LEBANON"),
	1396	_T("ARABIC_LIBYA"),
	1397	_T("ARABIC_MOROCCO"),
	1398	_T("ARABIC_OMAN"),
	1399	_T("ARABIC_QATAR"),
	1400	_T("ARABIC_SAUDI_ARABIA"),
	1401	_T("ARABIC_SUDAN"),
	1402	_T("ARABIC_SYRIA"),
	1403	_T("ARABIC_TUNISIA"),
	1404	_T("ARABIC_UAE"),
	1405	_T("ARABIC_YEMEN"),
	1406	_T("ARMENIAN"),
	1407	_T("ASSAMESE"),
	1408	_T("AYMARA"),
	1409	_T("AZERI"),
	1410	_T("AZERI_CYRILLIC"),
	1411	_T("AZERI_LATIN"),
	1412	_T("BASHKIR"),
	1413	_T("BASQUE"),
	1414	_T("BELARUSIAN"),
	1415	_T("BENGALI"),
	1416	_T("BHUTANI"),
	1417	_T("BIHARI"),
	1418	_T("BISLAMA"),
	1419	_T("BRETON"),
	1420	_T("BULGARIAN"),
	1421	_T("BURMESE"),
	1422	_T("CAMBODIAN"),
	1423	_T("CATALAN"),
	1424	_T("CHINESE"),
	1425	_T("CHINESE_SIMPLIFIED"),
	1426	_T("CHINESE_TRADITIONAL"),
	1427	_T("CHINESE_HONGKONG"),
	1428	_T("CHINESE_MACAU"),
	1429	_T("CHINESE_SINGAPORE"),
	1430	_T("CHINESE_TAIWAN"),
	1431	_T("CORSICAN"),
	1432	_T("CROATIAN"),
	1433	_T("CZECH"),
	1434	_T("DANISH"),
	1435	_T("DUTCH"),
	1436	_T("DUTCH_BELGIAN"),
	1437	_T("ENGLISH"),
	1438	_T("ENGLISH_UK"),
	1439	_T("ENGLISH_US"),
	1440	_T("ENGLISH_AUSTRALIA"),
	1441	_T("ENGLISH_BELIZE"),
	1442	_T("ENGLISH_BOTSWANA"),
	1443	_T("ENGLISH_CANADA"),
	1444	_T("ENGLISH_CARIBBEAN"),
	1445	_T("ENGLISH_DENMARK"),
	1446	_T("ENGLISH_EIRE"),
	1447	_T("ENGLISH_JAMAICA"),
	1448	_T("ENGLISH_NEW_ZEALAND"),
	1449	_T("ENGLISH_PHILIPPINES"),
	1450	_T("ENGLISH_SOUTH_AFRICA"),
	1451	_T("ENGLISH_TRINIDAD"),
	1452	_T("ENGLISH_ZIMBABWE"),
	1453	_T("ESPERANTO"),
	1454	_T("ESTONIAN"),
	1455	_T("FAEROESE"),
	1456	_T("FARSI"),
	1457	_T("FIJI"),
	1458	_T("FINNISH"),
	1459	_T("FRENCH"),
	1460	_T("FRENCH_BELGIAN"),
	1461	_T("FRENCH_CANADIAN"),
	1462	_T("FRENCH_LUXEMBOURG"),
	1463	_T("FRENCH_MONACO"),
	1464	_T("FRENCH_SWISS"),
	1465	_T("FRISIAN"),
	1466	_T("GALICIAN"),
	1467	_T("GEORGIAN"),
	1468	_T("GERMAN"),
	1469	_T("GERMAN_AUSTRIAN"),
	1470	_T("GERMAN_BELGIUM"),
	1471	_T("GERMAN_LIECHTENSTEIN"),
	1472	_T("GERMAN_LUXEMBOURG"),
	1473	_T("GERMAN_SWISS"),
	1474	_T("GREEK"),
	1475	_T("GREENLANDIC"),
	1476	_T("GUARANI"),
	1477	_T("GUJARATI"),
	1478	_T("HAUSA"),
	1479	_T("HEBREW"),
	1480	_T("HINDI"),
	1481	_T("HUNGARIAN"),
	1482	_T("ICELANDIC"),
	1483	_T("INDONESIAN"),
	1484	_T("INTERLINGUA"),
	1485	_T("INTERLINGUE"),
	1486	_T("INUKTITUT"),
	1487	_T("INUPIAK"),
	1488	_T("IRISH"),
	1489	_T("ITALIAN"),
	1490	_T("ITALIAN_SWISS"),
	1491	_T("JAPANESE"),
	1492	_T("JAVANESE"),
	1493	_T("KANNADA"),
	1494	_T("KASHMIRI"),
	1495	_T("KASHMIRI_INDIA"),
	1496	_T("KAZAKH"),
	1497	_T("KERNEWEK"),
	1498	_T("KINYARWANDA"),
	1499	_T("KIRGHIZ"),
	1500	_T("KIRUNDI"),
	1501	_T("KONKANI"),
	1502	_T("KOREAN"),
	1503	_T("KURDISH"),
	1504	_T("LAOTHIAN"),
	1505	_T("LATIN"),
	1506	_T("LATVIAN"),
	1507	_T("LINGALA"),
	1508	_T("LITHUANIAN"),
	1509	_T("MACEDONIAN"),
	1510	_T("MALAGASY"),
	1511	_T("MALAY"),
	1512	_T("MALAYALAM"),
	1513	_T("MALAY_BRUNEI_DARUSSALAM"),
	1514	_T("MALAY_MALAYSIA"),
	1515	_T("MALTESE"),
	1516	_T("MANIPURI"),
	1517	_T("MAORI"),
	1518	_T("MARATHI"),
	1519	_T("MOLDAVIAN"),
	1520	_T("MONGOLIAN"),
	1521	_T("NAURU"),
	1522	_T("NEPALI"),
	1523	_T("NEPALI_INDIA"),
	1524	_T("NORWEGIAN_BOKMAL"),
	1525	_T("NORWEGIAN_NYNORSK"),
	1526	_T("OCCITAN"),
	1527	_T("ORIYA"),
	1528	_T("OROMO"),
	1529	_T("PASHTO"),
	1530	_T("POLISH"),
	1531	_T("PORTUGUESE"),
	1532	_T("PORTUGUESE_BRAZILIAN"),
	1533	_T("PUNJABI"),
	1534	_T("QUECHUA"),
	1535	_T("RHAETO_ROMANCE"),
	1536	_T("ROMANIAN"),
	1537	_T("RUSSIAN"),
	1538	_T("RUSSIAN_UKRAINE"),
	1539	_T("SAMOAN"),
	1540	_T("SANGHO"),
	1541	_T("SANSKRIT"),
	1542	_T("SCOTS_GAELIC"),
	1543	_T("SERBIAN"),
	1544	_T("SERBIAN_CYRILLIC"),
	1545	_T("SERBIAN_LATIN"),
	1546	_T("SERBO_CROATIAN"),
	1547	_T("SESOTHO"),
	1548	_T("SETSWANA"),
	1549	_T("SHONA"),
	1550	_T("SINDHI"),
	1551	_T("SINHALESE"),
	1552	_T("SISWATI"),
	1553	_T("SLOVAK"),
	1554	_T("SLOVENIAN"),
	1555	_T("SOMALI"),
	1556	_T("SPANISH"),
	1557	_T("SPANISH_ARGENTINA"),
	1558	_T("SPANISH_BOLIVIA"),
	1559	_T("SPANISH_CHILE"),
	1560	_T("SPANISH_COLOMBIA"),
	1561	_T("SPANISH_COSTA_RICA"),
	1562	_T("SPANISH_DOMINICAN_REPUBLIC"),
	1563	_T("SPANISH_ECUADOR"),
	1564	_T("SPANISH_EL_SALVADOR"),
	1565	_T("SPANISH_GUATEMALA"),
	1566	_T("SPANISH_HONDURAS"),
	1567	_T("SPANISH_MEXICAN"),
	1568	_T("SPANISH_MODERN"),
	1569	_T("SPANISH_NICARAGUA"),
	1570	_T("SPANISH_PANAMA"),
	1571	_T("SPANISH_PARAGUAY"),
	1572	_T("SPANISH_PERU"),
	1573	_T("SPANISH_PUERTO_RICO"),
	1574	_T("SPANISH_URUGUAY"),
	1575	_T("SPANISH_US"),
	1576	_T("SPANISH_VENEZUELA"),
	1577	_T("SUNDANESE"),
	1578	_T("SWAHILI"),
	1579	_T("SWEDISH"),
	1580	_T("SWEDISH_FINLAND"),
	1581	_T("TAGALOG"),
	1582	_T("TAJIK"),
	1583	_T("TAMIL"),
	1584	_T("TATAR"),
	1585	_T("TELUGU"),
	1586	_T("THAI"),
	1587	_T("TIBETAN"),
	1588	_T("TIGRINYA"),
	1589	_T("TONGA"),
	1590	_T("TSONGA"),
	1591	_T("TURKISH"),
	1592	_T("TURKMEN"),
	1593	_T("TWI"),
	1594	_T("UIGHUR"),
	1595	_T("UKRAINIAN"),
	1596	_T("URDU"),
	1597	_T("URDU_INDIA"),
	1598	_T("URDU_PAKISTAN"),
	1599	_T("UZBEK"),
	1600	_T("UZBEK_CYRILLIC"),
	1601	_T("UZBEK_LATIN"),
	1602	_T("VIETNAMESE"),
	1603	_T("VOLAPUK"),
	1604	_T("WELSH"),
	1605	_T("WOLOF"),
	1606	_T("XHOSA"),
	1607	_T("YIDDISH"),
	1608	_T("YORUBA"),
	1609	_T("ZHUANG"),
	1610	_T("ZULU"),
	1611	};
	1612
	1613	if ( (size_t)lang < WXSIZEOF(languageNames) )
	1614	return languageNames[lang];
	1615	else
	1616	return _T("INVALID");
	1617	}
	1618
	1619	static void TestDefaultLang()
	1620	{
	1621	wxPuts(_T("* Testing wxLocale::GetSystemLanguage *"));
	1622
	1623	static const wxChar *langStrings[] =
	1624	{
	1625	NULL, // system default
	1626	_T("C"),
	1627	_T("fr"),
	1628	_T("fr_FR"),
	1629	_T("en"),
	1630	_T("en_GB"),
	1631	_T("en_US"),
	1632	_T("de_DE.iso88591"),
	1633	_T("german"),
	1634	_T("?"), // invalid lang spec
	1635	_T("klingonese"), // I bet on some systems it does exist...
	1636	};
	1637
	1638	wxPrintf(_T("The default system encoding is %s (%d)\n"),
	1639	wxLocale::GetSystemEncodingName().c_str(),
	1640	wxLocale::GetSystemEncoding());
	1641
	1642	for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
	1643	{
	1644	const wxChar *langStr = langStrings[n];
	1645	if ( langStr )
	1646	{
	1647	// FIXME: this doesn't do anything at all under Windows, we need
	1648	// to create a new wxLocale!
	1649	wxSetEnv(_T("LC_ALL"), langStr);
	1650	}
	1651
	1652	int lang = gs_localeDefault.GetSystemLanguage();
	1653	wxPrintf(_T("Locale for '%s' is %s.\n"),
	1654	langStr ? langStr : _T("system default"), GetLangName(lang));
	1655	}
	1656	}
	1657
	1658	#endif // TEST_LOCALE
	1659
	1660	// ----------------------------------------------------------------------------
	1661	// MIME types
	1662	// ----------------------------------------------------------------------------
	1663
	1664	#ifdef TEST_MIME
	1665
	1666	#include "wx/mimetype.h"
	1667
	1668	static void TestMimeEnum()
	1669	{
	1670	wxPuts(_T("* Testing wxMimeTypesManager::EnumAllFileTypes() *\n"));
	1671
	1672	wxArrayString mimetypes;
	1673
	1674	size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
	1675
	1676	wxPrintf(_T("* All %u known filetypes: *\n"), count);
	1677
	1678	wxArrayString exts;
	1679	wxString desc;
	1680
	1681	for ( size_t n = 0; n < count; n++ )
	1682	{
	1683	wxFileType *filetype =
	1684	wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
	1685	if ( !filetype )
	1686	{
	1687	wxPrintf(_T("nothing known about the filetype '%s'!\n"),
	1688	mimetypes[n].c_str());
	1689	continue;
	1690	}
	1691
	1692	filetype->GetDescription(&desc);
	1693	filetype->GetExtensions(exts);
	1694
	1695	filetype->GetIcon(NULL);
	1696
	1697	wxString extsAll;
	1698	for ( size_t e = 0; e < exts.GetCount(); e++ )
	1699	{
	1700	if ( e > 0 )
	1701	extsAll << _T(", ");
	1702	extsAll += exts[e];
	1703	}
	1704
	1705	wxPrintf(_T("\t%s: %s (%s)\n"),
	1706	mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
	1707	}
	1708
	1709	wxPuts(_T(""));
	1710	}
	1711
	1712	static void TestMimeOverride()
	1713	{
	1714	wxPuts(_T("* Testing wxMimeTypesManager additional files loading *\n"));
	1715
	1716	static const wxChar *mailcap = _T("/tmp/mailcap");
	1717	static const wxChar *mimetypes = _T("/tmp/mime.types");
	1718
	1719	if ( wxFile::Exists(mailcap) )
	1720	wxPrintf(_T("Loading mailcap from '%s': %s\n"),
	1721	mailcap,
	1722	wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
	1723	else
	1724	wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
	1725	mailcap);
	1726
	1727	if ( wxFile::Exists(mimetypes) )
	1728	wxPrintf(_T("Loading mime.types from '%s': %s\n"),
	1729	mimetypes,
	1730	wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
	1731	else
	1732	wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
	1733	mimetypes);
	1734
	1735	wxPuts(_T(""));
	1736	}
	1737
	1738	static void TestMimeFilename()
	1739	{
	1740	wxPuts(_T("* Testing MIME type from filename query *\n"));
	1741
	1742	static const wxChar *filenames[] =
	1743	{
	1744	_T("readme.txt"),
	1745	_T("document.pdf"),
	1746	_T("image.gif"),
	1747	_T("picture.jpeg"),
	1748	};
	1749
	1750	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	1751	{
	1752	const wxString fname = filenames[n];
	1753	wxString ext = fname.AfterLast(_T('.'));
	1754	wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
	1755	if ( !ft )
	1756	{
	1757	wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
	1758	}
	1759	else
	1760	{
	1761	wxString desc;
	1762	if ( !ft->GetDescription(&desc) )
	1763	desc = _T("<no description>");
	1764
	1765	wxString cmd;
	1766	if ( !ft->GetOpenCommand(&cmd,
	1767	wxFileType::MessageParameters(fname, _T(""))) )
	1768	cmd = _T("<no command available>");
	1769	else
	1770	cmd = wxString(_T('"')) + cmd + _T('"');
	1771
	1772	wxPrintf(_T("To open %s (%s) do %s.\n"),
	1773	fname.c_str(), desc.c_str(), cmd.c_str());
	1774
	1775	delete ft;
	1776	}
	1777	}
	1778
	1779	wxPuts(_T(""));
	1780	}
	1781
	1782	static void TestMimeAssociate()
	1783	{
	1784	wxPuts(_T("* Testing creation of filetype association *\n"));
	1785
	1786	wxFileTypeInfo ftInfo(
	1787	_T("application/x-xyz"),
	1788	_T("xyzview '%s'"), // open cmd
	1789	_T(""), // print cmd
	1790	_T("XYZ File"), // description
	1791	_T(".xyz"), // extensions
	1792	NULL // end of extensions
	1793	);
	1794	ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
	1795
	1796	wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
	1797	if ( !ft )
	1798	{
	1799	wxPuts(_T("ERROR: failed to create association!"));
	1800	}
	1801	else
	1802	{
	1803	// TODO: read it back
	1804	delete ft;
	1805	}
	1806
	1807	wxPuts(_T(""));
	1808	}
	1809
	1810	#endif // TEST_MIME
	1811
	1812	// ----------------------------------------------------------------------------
	1813	// misc information functions
	1814	// ----------------------------------------------------------------------------
	1815
	1816	#ifdef TEST_INFO_FUNCTIONS
	1817
	1818	#include "wx/utils.h"
	1819
	1820	static void TestDiskInfo()
	1821	{
	1822	wxPuts(_T("* Testing wxGetDiskSpace() *"));
	1823
	1824	for ( ;; )
	1825	{
	1826	wxChar pathname[128];
	1827	wxPrintf(_T("\nEnter a directory name: "));
	1828	if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
	1829	break;
	1830
	1831	// kill the last '\n'
	1832	pathname[wxStrlen(pathname) - 1] = 0;
	1833
	1834	wxLongLong total, free;
	1835	if ( !wxGetDiskSpace(pathname, &total, &free) )
	1836	{
	1837	wxPuts(_T("ERROR: wxGetDiskSpace failed."));
	1838	}
	1839	else
	1840	{
	1841	wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
	1842	(total / 1024).ToString().c_str(),
	1843	(free / 1024).ToString().c_str(),
	1844	pathname);
	1845	}
	1846	}
	1847	}
	1848
	1849	static void TestOsInfo()
	1850	{
	1851	wxPuts(_T("* Testing OS info functions *\n"));
	1852
	1853	int major, minor;
	1854	wxGetOsVersion(&major, &minor);
	1855	wxPrintf(_T("Running under: %s, version %d.%d\n"),
	1856	wxGetOsDescription().c_str(), major, minor);
	1857
	1858	wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory());
	1859
	1860	wxPrintf(_T("Host name is %s (%s).\n"),
	1861	wxGetHostName().c_str(), wxGetFullHostName().c_str());
	1862
	1863	wxPuts(_T(""));
	1864	}
	1865
	1866	static void TestUserInfo()
	1867	{
	1868	wxPuts(_T("* Testing user info functions *\n"));
	1869
	1870	wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
	1871	wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
	1872	wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
	1873	wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
	1874
	1875	wxPuts(_T(""));
	1876	}
	1877
	1878	#endif // TEST_INFO_FUNCTIONS
	1879
	1880	// ----------------------------------------------------------------------------
	1881	// long long
	1882	// ----------------------------------------------------------------------------
	1883
	1884	#ifdef TEST_LONGLONG
	1885
	1886	#include "wx/longlong.h"
	1887	#include "wx/timer.h"
	1888
	1889	// make a 64 bit number from 4 16 bit ones
	1890	#define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) \| x2, (x3 << 16) \| x3)
	1891
	1892	// get a random 64 bit number
	1893	#define RAND_LL() MAKE_LL(rand(), rand(), rand(), rand())
	1894
	1895	static const long testLongs[] =
	1896	{
	1897	0,
	1898	1,
	1899	-1,
	1900	LONG_MAX,
	1901	LONG_MIN,
	1902	0x1234,
	1903	-0x1234
	1904	};
	1905
	1906	#if wxUSE_LONGLONG_WX
	1907	inline bool operator==(const wxLongLongWx& a, const wxLongLongNative& b)
	1908	{ return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
	1909	inline bool operator==(const wxLongLongNative& a, const wxLongLongWx& b)
	1910	{ return a.GetHi() == b.GetHi() && a.GetLo() == b.GetLo(); }
	1911	#endif // wxUSE_LONGLONG_WX
	1912
	1913	static void TestSpeed()
	1914	{
	1915	static const long max = 100000000;
	1916	long n;
	1917
	1918	{
	1919	wxStopWatch sw;
	1920
	1921	long l = 0;
	1922	for ( n = 0; n < max; n++ )
	1923	{
	1924	l += n;
	1925	}
	1926
	1927	wxPrintf(_T("Summing longs took %ld milliseconds.\n"), sw.Time());
	1928	}
	1929
	1930	#if wxUSE_LONGLONG_NATIVE
	1931	{
	1932	wxStopWatch sw;
	1933
	1934	wxLongLong_t l = 0;
	1935	for ( n = 0; n < max; n++ )
	1936	{
	1937	l += n;
	1938	}
	1939
	1940	wxPrintf(_T("Summing wxLongLong_t took %ld milliseconds.\n"), sw.Time());
	1941	}
	1942	#endif // wxUSE_LONGLONG_NATIVE
	1943
	1944	{
	1945	wxStopWatch sw;
	1946
	1947	wxLongLong l;
	1948	for ( n = 0; n < max; n++ )
	1949	{
	1950	l += n;
	1951	}
	1952
	1953	wxPrintf(_T("Summing wxLongLongs took %ld milliseconds.\n"), sw.Time());
	1954	}
	1955	}
	1956
	1957	static void TestLongLongConversion()
	1958	{
	1959	wxPuts(_T("* Testing wxLongLong conversions *\n"));
	1960
	1961	wxLongLong a;
	1962	size_t nTested = 0;
	1963	for ( size_t n = 0; n < 100000; n++ )
	1964	{
	1965	a = RAND_LL();
	1966
	1967	#if wxUSE_LONGLONG_NATIVE
	1968	wxLongLongNative b(a.GetHi(), a.GetLo());
	1969
	1970	wxASSERT_MSG( a == b, "conversions failure" );
	1971	#else
	1972	wxPuts(_T("Can't do it without native long long type, test skipped."));
	1973
	1974	return;
	1975	#endif // wxUSE_LONGLONG_NATIVE
	1976
	1977	if ( !(nTested % 1000) )
	1978	{
	1979	putchar('.');
	1980	fflush(stdout);
	1981	}
	1982
	1983	nTested++;
	1984	}
	1985
	1986	wxPuts(_T(" done!"));
	1987	}
	1988
	1989	static void TestMultiplication()
	1990	{
	1991	wxPuts(_T("* Testing wxLongLong multiplication *\n"));
	1992
	1993	wxLongLong a, b;
	1994	size_t nTested = 0;
	1995	for ( size_t n = 0; n < 100000; n++ )
	1996	{
	1997	a = RAND_LL();
	1998	b = RAND_LL();
	1999
	2000	#if wxUSE_LONGLONG_NATIVE
	2001	wxLongLongNative aa(a.GetHi(), a.GetLo());
	2002	wxLongLongNative bb(b.GetHi(), b.GetLo());
	2003
	2004	wxASSERT_MSG( ab == aabb, "multiplication failure" );
	2005	#else // !wxUSE_LONGLONG_NATIVE
	2006	wxPuts(_T("Can't do it without native long long type, test skipped."));
	2007
	2008	return;
	2009	#endif // wxUSE_LONGLONG_NATIVE
	2010
	2011	if ( !(nTested % 1000) )
	2012	{
	2013	putchar('.');
	2014	fflush(stdout);
	2015	}
	2016
	2017	nTested++;
	2018	}
	2019
	2020	wxPuts(_T(" done!"));
	2021	}
	2022
	2023	static void TestDivision()
	2024	{
	2025	wxPuts(_T("* Testing wxLongLong division *\n"));
	2026
	2027	wxLongLong q, r;
	2028	size_t nTested = 0;
	2029	for ( size_t n = 0; n < 100000; n++ )
	2030	{
	2031	// get a random wxLongLong (shifting by 12 the MSB ensures that the
	2032	// multiplication will not overflow)
	2033	wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
	2034
	2035	// get a random (but non null) long (not wxLongLong for now) to divide
	2036	// it with
	2037	long l;
	2038	do
	2039	{
	2040	l = rand();
	2041	}
	2042	while ( !l );
	2043
	2044	q = ll / l;
	2045	r = ll % l;
	2046
	2047	#if wxUSE_LONGLONG_NATIVE
	2048	wxLongLongNative m(ll.GetHi(), ll.GetLo());
	2049
	2050	wxLongLongNative p = m / l, s = m % l;
	2051	wxASSERT_MSG( q == p && r == s, "division failure" );
	2052	#else // !wxUSE_LONGLONG_NATIVE
	2053	// verify the result
	2054	wxASSERT_MSG( ll == q*l + r, "division failure" );
	2055	#endif // wxUSE_LONGLONG_NATIVE
	2056
	2057	if ( !(nTested % 1000) )
	2058	{
	2059	putchar('.');
	2060	fflush(stdout);
	2061	}
	2062
	2063	nTested++;
	2064	}
	2065
	2066	wxPuts(_T(" done!"));
	2067	}
	2068
	2069	static void TestAddition()
	2070	{
	2071	wxPuts(_T("* Testing wxLongLong addition *\n"));
	2072
	2073	wxLongLong a, b, c;
	2074	size_t nTested = 0;
	2075	for ( size_t n = 0; n < 100000; n++ )
	2076	{
	2077	a = RAND_LL();
	2078	b = RAND_LL();
	2079	c = a + b;
	2080
	2081	#if wxUSE_LONGLONG_NATIVE
	2082	wxASSERT_MSG( c == wxLongLongNative(a.GetHi(), a.GetLo()) +
	2083	wxLongLongNative(b.GetHi(), b.GetLo()),
	2084	"addition failure" );
	2085	#else // !wxUSE_LONGLONG_NATIVE
	2086	wxASSERT_MSG( c - b == a, "addition failure" );
	2087	#endif // wxUSE_LONGLONG_NATIVE
	2088
	2089	if ( !(nTested % 1000) )
	2090	{
	2091	putchar('.');
	2092	fflush(stdout);
	2093	}
	2094
	2095	nTested++;
	2096	}
	2097
	2098	wxPuts(_T(" done!"));
	2099	}
	2100
	2101	static void TestBitOperations()
	2102	{
	2103	wxPuts(_T("* Testing wxLongLong bit operation *\n"));
	2104
	2105	wxLongLong ll;
	2106	size_t nTested = 0;
	2107	for ( size_t n = 0; n < 100000; n++ )
	2108	{
	2109	ll = RAND_LL();
	2110
	2111	#if wxUSE_LONGLONG_NATIVE
	2112	for ( size_t n = 0; n < 33; n++ )
	2113	{
	2114	}
	2115	#else // !wxUSE_LONGLONG_NATIVE
	2116	wxPuts(_T("Can't do it without native long long type, test skipped."));
	2117
	2118	return;
	2119	#endif // wxUSE_LONGLONG_NATIVE
	2120
	2121	if ( !(nTested % 1000) )
	2122	{
	2123	putchar('.');
	2124	fflush(stdout);
	2125	}
	2126
	2127	nTested++;
	2128	}
	2129
	2130	wxPuts(_T(" done!"));
	2131	}
	2132
	2133	static void TestLongLongComparison()
	2134	{
	2135	#if wxUSE_LONGLONG_WX
	2136	wxPuts(_T("* Testing wxLongLong comparison *\n"));
	2137
	2138	static const long ls[2] =
	2139	{
	2140	0x1234,
	2141	-0x1234,
	2142	};
	2143
	2144	wxLongLongWx lls[2];
	2145	lls[0] = ls[0];
	2146	lls[1] = ls[1];
	2147
	2148	for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
	2149	{
	2150	bool res;
	2151
	2152	for ( size_t m = 0; m < WXSIZEOF(lls); m++ )
	2153	{
	2154	res = lls[m] > testLongs[n];
	2155	wxPrintf(_T("0x%lx > 0x%lx is %s (%s)\n"),
	2156	ls[m], testLongs[n], res ? "true" : "false",
	2157	res == (ls[m] > testLongs[n]) ? "ok" : "ERROR");
	2158
	2159	res = lls[m] < testLongs[n];
	2160	wxPrintf(_T("0x%lx < 0x%lx is %s (%s)\n"),
	2161	ls[m], testLongs[n], res ? "true" : "false",
	2162	res == (ls[m] < testLongs[n]) ? "ok" : "ERROR");
	2163
	2164	res = lls[m] == testLongs[n];
	2165	wxPrintf(_T("0x%lx == 0x%lx is %s (%s)\n"),
	2166	ls[m], testLongs[n], res ? "true" : "false",
	2167	res == (ls[m] == testLongs[n]) ? "ok" : "ERROR");
	2168	}
	2169	}
	2170	#endif // wxUSE_LONGLONG_WX
	2171	}
	2172
	2173	static void TestLongLongToString()
	2174	{
	2175	wxPuts(_T("* Testing wxLongLong::ToString() *\n"));
	2176
	2177	for ( size_t n = 0; n < WXSIZEOF(testLongs); n++ )
	2178	{
	2179	wxLongLong ll = testLongs[n];
	2180	wxPrintf(_T("%ld == %s\n"), testLongs[n], ll.ToString().c_str());
	2181	}
	2182
	2183	wxLongLong ll(0x12345678, 0x87654321);
	2184	wxPrintf(_T("0x1234567887654321 = %s\n"), ll.ToString().c_str());
	2185
	2186	ll.Negate();
	2187	wxPrintf(_T("-0x1234567887654321 = %s\n"), ll.ToString().c_str());
	2188	}
	2189
	2190	static void TestLongLongPrintf()
	2191	{
	2192	wxPuts(_T("* Testing wxLongLong printing *\n"));
	2193
	2194	#ifdef wxLongLongFmtSpec
	2195	wxLongLong ll = wxLL(0x1234567890abcdef);
	2196	wxString s = wxString::Format(_T("%") wxLongLongFmtSpec _T("x"), ll);
	2197	wxPrintf(_T("0x1234567890abcdef -> %s (%s)\n"),
	2198	s.c_str(), s == _T("1234567890abcdef") ? _T("ok") : _T("ERROR"));
	2199	#else // !wxLongLongFmtSpec
	2200	#error "wxLongLongFmtSpec not defined for this compiler/platform"
	2201	#endif
	2202	}
	2203
	2204	#undef MAKE_LL
	2205	#undef RAND_LL
	2206
	2207	#endif // TEST_LONGLONG
	2208
	2209	// ----------------------------------------------------------------------------
	2210	// path list
	2211	// ----------------------------------------------------------------------------
	2212
	2213	#ifdef TEST_PATHLIST
	2214
	2215	#ifdef __UNIX__
	2216	#define CMD_IN_PATH _T("ls")
	2217	#else
	2218	#define CMD_IN_PATH _T("command.com")
	2219	#endif
	2220
	2221	static void TestPathList()
	2222	{
	2223	wxPuts(_T("* Testing wxPathList *\n"));
	2224
	2225	wxPathList pathlist;
	2226	pathlist.AddEnvList(_T("PATH"));
	2227	wxString path = pathlist.FindValidPath(CMD_IN_PATH);
	2228	if ( path.empty() )
	2229	{
	2230	wxPrintf(_T("ERROR: command not found in the path.\n"));
	2231	}
	2232	else
	2233	{
	2234	wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
	2235	}
	2236	}
	2237
	2238	#endif // TEST_PATHLIST
	2239
	2240	// ----------------------------------------------------------------------------
	2241	// regular expressions
	2242	// ----------------------------------------------------------------------------
	2243
	2244	#ifdef TEST_REGEX
	2245
	2246	#include "wx/regex.h"
	2247
	2248	static void TestRegExCompile()
	2249	{
	2250	wxPuts(_T("* Testing RE compilation *\n"));
	2251
	2252	static struct RegExCompTestData
	2253	{
	2254	const wxChar *pattern;
	2255	bool correct;
	2256	} regExCompTestData[] =
	2257	{
	2258	{ _T("foo"), TRUE },
	2259	{ _T("foo("), FALSE },
	2260	{ _T("foo(bar"), FALSE },
	2261	{ _T("foo(bar)"), TRUE },
	2262	{ _T("foo["), FALSE },
	2263	{ _T("foo[bar"), FALSE },
	2264	{ _T("foo[bar]"), TRUE },
	2265	{ _T("foo{"), TRUE },
	2266	{ _T("foo{1"), FALSE },
	2267	{ _T("foo{bar"), TRUE },
	2268	{ _T("foo{1}"), TRUE },
	2269	{ _T("foo{1,2}"), TRUE },
	2270	{ _T("foo{bar}"), TRUE },
	2271	{ _T("foo*"), TRUE },
	2272	{ _T("foo**"), FALSE },
	2273	{ _T("foo+"), TRUE },
	2274	{ _T("foo++"), FALSE },
	2275	{ _T("foo?"), TRUE },
	2276	{ _T("foo??"), FALSE },
	2277	{ _T("foo?+"), FALSE },
	2278	};
	2279
	2280	wxRegEx re;
	2281	for ( size_t n = 0; n < WXSIZEOF(regExCompTestData); n++ )
	2282	{
	2283	const RegExCompTestData& data = regExCompTestData[n];
	2284	bool ok = re.Compile(data.pattern);
	2285
	2286	wxPrintf(_T("'%s' is %sa valid RE (%s)\n"),
	2287	data.pattern,
	2288	ok ? _T("") : _T("not "),
	2289	ok == data.correct ? _T("ok") : _T("ERROR"));
	2290	}
	2291	}
	2292
	2293	static void TestRegExMatch()
	2294	{
	2295	wxPuts(_T("* Testing RE matching *\n"));
	2296
	2297	static struct RegExMatchTestData
	2298	{
	2299	const wxChar *pattern;
	2300	const wxChar *text;
	2301	bool correct;
	2302	} regExMatchTestData[] =
	2303	{
	2304	{ _T("foo"), _T("bar"), FALSE },
	2305	{ _T("foo"), _T("foobar"), TRUE },
	2306	{ _T("^foo"), _T("foobar"), TRUE },
	2307	{ _T("^foo"), _T("barfoo"), FALSE },
	2308	{ _T("bar$"), _T("barbar"), TRUE },
	2309	{ _T("bar$"), _T("barbar "), FALSE },
	2310	};
	2311
	2312	for ( size_t n = 0; n < WXSIZEOF(regExMatchTestData); n++ )
	2313	{
	2314	const RegExMatchTestData& data = regExMatchTestData[n];
	2315
	2316	wxRegEx re(data.pattern);
	2317	bool ok = re.Matches(data.text);
	2318
	2319	wxPrintf(_T("'%s' %s %s (%s)\n"),
	2320	data.pattern,
	2321	ok ? _T("matches") : _T("doesn't match"),
	2322	data.text,
	2323	ok == data.correct ? _T("ok") : _T("ERROR"));
	2324	}
	2325	}
	2326
	2327	static void TestRegExSubmatch()
	2328	{
	2329	wxPuts(_T("* Testing RE subexpressions *\n"));
	2330
	2331	wxRegEx re(_T("([[:alpha:]]+) ([[:alpha:]]+) ([[:digit:]]+).*([[:digit:]]+)$"));
	2332	if ( !re.IsValid() )
	2333	{
	2334	wxPuts(_T("ERROR: compilation failed."));
	2335	return;
	2336	}
	2337
	2338	wxString text = _T("Fri Jul 13 18:37:52 CEST 2001");
	2339
	2340	if ( !re.Matches(text) )
	2341	{
	2342	wxPuts(_T("ERROR: match expected."));
	2343	}
	2344	else
	2345	{
	2346	wxPrintf(_T("Entire match: %s\n"), re.GetMatch(text).c_str());
	2347
	2348	wxPrintf(_T("Date: %s/%s/%s, wday: %s\n"),
	2349	re.GetMatch(text, 3).c_str(),
	2350	re.GetMatch(text, 2).c_str(),
	2351	re.GetMatch(text, 4).c_str(),
	2352	re.GetMatch(text, 1).c_str());
	2353	}
	2354	}
	2355
	2356	static void TestRegExReplacement()
	2357	{
	2358	wxPuts(_T("* Testing RE replacement *"));
	2359
	2360	static struct RegExReplTestData
	2361	{
	2362	const wxChar *text;
	2363	const wxChar *repl;
	2364	const wxChar *result;
	2365	size_t count;
	2366	} regExReplTestData[] =
	2367	{
	2368	{ _T("foo123"), _T("bar"), _T("bar"), 1 },
	2369	{ _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
	2370	{ _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
	2371	{ _T("123foo"), _T("bar"), _T("123foo"), 0 },
	2372	{ _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
	2373	{ _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
	2374	{ _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
	2375	};
	2376
	2377	const wxChar pattern = _T("([a-z]+)[^0-9]([0-9]+)");
	2378	wxRegEx re(pattern);
	2379
	2380	wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern);
	2381
	2382	for ( size_t n = 0; n < WXSIZEOF(regExReplTestData); n++ )
	2383	{
	2384	const RegExReplTestData& data = regExReplTestData[n];
	2385
	2386	wxString text = data.text;
	2387	size_t nRepl = re.Replace(&text, data.repl);
	2388
	2389	wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
	2390	data.text, data.repl,
	2391	nRepl, nRepl == 1 ? _T("") : _T("es"),
	2392	text.c_str());
	2393	if ( text == data.result && nRepl == data.count )
	2394	{
	2395	wxPuts(_T("ok)"));
	2396	}
	2397	else
	2398	{
	2399	wxPrintf(_T("ERROR: should be %u and '%s')\n"),
	2400	data.count, data.result);
	2401	}
	2402	}
	2403	}
	2404
	2405	static void TestRegExInteractive()
	2406	{
	2407	wxPuts(_T("* Testing RE interactively *"));
	2408
	2409	for ( ;; )
	2410	{
	2411	wxChar pattern[128];
	2412	wxPrintf(_T("\nEnter a pattern: "));
	2413	if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
	2414	break;
	2415
	2416	// kill the last '\n'
	2417	pattern[wxStrlen(pattern) - 1] = 0;
	2418
	2419	wxRegEx re;
	2420	if ( !re.Compile(pattern) )
	2421	{
	2422	continue;
	2423	}
	2424
	2425	wxChar text[128];
	2426	for ( ;; )
	2427	{
	2428	wxPrintf(_T("Enter text to match: "));
	2429	if ( !wxFgets(text, WXSIZEOF(text), stdin) )
	2430	break;
	2431
	2432	// kill the last '\n'
	2433	text[wxStrlen(text) - 1] = 0;
	2434
	2435	if ( !re.Matches(text) )
	2436	{
	2437	wxPrintf(_T("No match.\n"));
	2438	}
	2439	else
	2440	{
	2441	wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
	2442
	2443	size_t start, len;
	2444	for ( size_t n = 1; ; n++ )
	2445	{
	2446	if ( !re.GetMatch(&start, &len, n) )
	2447	{
	2448	break;
	2449	}
	2450
	2451	wxPrintf(_T("Subexpr %u matched '%s'\n"),
	2452	n, wxString(text + start, len).c_str());
	2453	}
	2454	}
	2455	}
	2456	}
	2457	}
	2458
	2459	#endif // TEST_REGEX
	2460
	2461	// ----------------------------------------------------------------------------
	2462	// database
	2463	// ----------------------------------------------------------------------------
	2464
	2465	#if !wxUSE_ODBC
	2466	#undef TEST_ODBC
	2467	#endif
	2468
	2469	#ifdef TEST_ODBC
	2470
	2471	#include <wx/db.h>
	2472
	2473	static void TestDbOpen()
	2474	{
	2475	HENV henv;
	2476	wxDb db(henv);
	2477	}
	2478
	2479	#endif // TEST_ODBC
	2480
	2481	// ----------------------------------------------------------------------------
	2482	// printf() tests
	2483	// ----------------------------------------------------------------------------
	2484
	2485	/*
	2486	NB: this stuff was taken from the glibc test suite and modified to build
	2487	in wxWindows: if I read the copyright below properly, this shouldn't
	2488	be a problem
	2489	*/
	2490
	2491	#ifdef TEST_PRINTF
	2492
	2493	#ifdef wxTEST_PRINTF
	2494	// use our functions from wxchar.cpp
	2495	#undef wxPrintf
	2496	#undef wxSprintf
	2497
	2498	// NB: do _not_ use ATTRIBUTE_PRINTF here, we have some invalid formats
	2499	// in the tests below
	2500	int wxPrintf( const wxChar *format, ... );
	2501	int wxSprintf( wxChar str, const wxChar format, ... );
	2502	#endif
	2503
	2504	#include "wx/longlong.h"
	2505
	2506	#include <float.h>
	2507
	2508	static void rfg1 (void);
	2509	static void rfg2 (void);
	2510
	2511
	2512	static void
	2513	fmtchk (const wxChar *fmt)
	2514	{
	2515	(void) wxPrintf(_T("%s:\t`"), fmt);
	2516	(void) wxPrintf(fmt, 0x12);
	2517	(void) wxPrintf(_T("'\n"));
	2518	}
	2519
	2520	static void
	2521	fmtst1chk (const wxChar *fmt)
	2522	{
	2523	(void) wxPrintf(_T("%s:\t`"), fmt);
	2524	(void) wxPrintf(fmt, 4, 0x12);
	2525	(void) wxPrintf(_T("'\n"));
	2526	}
	2527
	2528	static void
	2529	fmtst2chk (const wxChar *fmt)
	2530	{
	2531	(void) wxPrintf(_T("%s:\t`"), fmt);
	2532	(void) wxPrintf(fmt, 4, 4, 0x12);
	2533	(void) wxPrintf(_T("'\n"));
	2534	}
	2535
	2536	/* This page is covered by the following copyright: */
	2537
	2538	/* (C) Copyright C E Chew
	2539	*
	2540	* Feel free to copy, use and distribute this software provided:
	2541	*
	2542	* 1. you do not pretend that you wrote it
	2543	* 2. you leave this copyright notice intact.
	2544	*/
	2545
	2546	/*
	2547	* Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
	2548	*/
	2549
	2550	#define DEC -123
	2551	#define INT 255
	2552	#define UNS (~0)
	2553
	2554	/* Formatted Output Test
	2555	*
	2556	* This exercises the output formatting code.
	2557	*/
	2558
	2559	static void
	2560	fp_test (void)
	2561	{
	2562	int i, j, k, l;
	2563	wxChar buf[7];
	2564	wxChar *prefix = buf;
	2565	wxChar tp[20];
	2566
	2567	wxPuts(_T("\nFormatted output test"));
	2568	wxPrintf(_T("prefix 6d 6o 6x 6X 6u\n"));
	2569	wxStrcpy(prefix, _T("%"));
	2570	for (i = 0; i < 2; i++) {
	2571	for (j = 0; j < 2; j++) {
	2572	for (k = 0; k < 2; k++) {
	2573	for (l = 0; l < 2; l++) {
	2574	wxStrcpy(prefix, _T("%"));
	2575	if (i == 0) wxStrcat(prefix, _T("-"));
	2576	if (j == 0) wxStrcat(prefix, _T("+"));
	2577	if (k == 0) wxStrcat(prefix, _T("#"));
	2578	if (l == 0) wxStrcat(prefix, _T("0"));
	2579	wxPrintf(_T("%5s \|"), prefix);
	2580	wxStrcpy(tp, prefix);
	2581	wxStrcat(tp, _T("6d \|"));
	2582	wxPrintf(tp, DEC);
	2583	wxStrcpy(tp, prefix);
	2584	wxStrcat(tp, _T("6o \|"));
	2585	wxPrintf(tp, INT);
	2586	wxStrcpy(tp, prefix);
	2587	wxStrcat(tp, _T("6x \|"));
	2588	wxPrintf(tp, INT);
	2589	wxStrcpy(tp, prefix);
	2590	wxStrcat(tp, _T("6X \|"));
	2591	wxPrintf(tp, INT);
	2592	wxStrcpy(tp, prefix);
	2593	wxStrcat(tp, _T("6u \|"));
	2594	wxPrintf(tp, UNS);
	2595	wxPrintf(_T("\n"));
	2596	}
	2597	}
	2598	}
	2599	}
	2600	wxPrintf(_T("%10s\n"), (wxChar *) NULL);
	2601	wxPrintf(_T("%-10s\n"), (wxChar *) NULL);
	2602	}
	2603
	2604	static void TestPrintf()
	2605	{
	2606	static wxChar shortstr[] = _T("Hi, Z.");
	2607	static wxChar longstr[] = _T("Good morning, Doctor Chandra. This is Hal. \
	2608	I am ready for my first lesson today.");
	2609	int result = 0;
	2610
	2611	fmtchk(_T("%.4x"));
	2612	fmtchk(_T("%04x"));
	2613	fmtchk(_T("%4.4x"));
	2614	fmtchk(_T("%04.4x"));
	2615	fmtchk(_T("%4.3x"));
	2616	fmtchk(_T("%04.3x"));
	2617
	2618	fmtst1chk(_T("%.*x"));
	2619	fmtst1chk(_T("%0*x"));
	2620	fmtst2chk(_T("%.x"));
	2621	fmtst2chk(_T("%0.x"));
	2622
	2623	wxPrintf(_T("bad format:\t\"%b\"\n"));
	2624	wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
	2625
	2626	wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
	2627	wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
	2628	wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
	2629	wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
	2630	wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
	2631	wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
	2632	wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
	2633	wxPrintf(_T("left-adjusted ZLDN:\t\"%-010ld\"\n"), -123456);
	2634	wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
	2635	wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
	2636
	2637	wxPrintf(_T("zero-padded string:\t\"%010s\"\n"), shortstr);
	2638	wxPrintf(_T("left-adjusted Z string:\t\"%-010s\"\n"), shortstr);
	2639	wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
	2640	wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
	2641	wxPrintf(_T("null string:\t\"%s\"\n"), (wxChar *)NULL);
	2642	wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr);
	2643
	2644	wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
	2645	wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
	2646	wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
	2647	wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20);
	2648	wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
	2649	wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
	2650	wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
	2651	wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
	2652	wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
	2653	wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
	2654	wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
	2655	wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20);
	2656
	2657	wxPrintf (_T(" %6.5f\n"), .099999999860301614);
	2658	wxPrintf (_T(" %6.5f\n"), .1);
	2659	wxPrintf (_T("x%5.4fx\n"), .5);
	2660
	2661	wxPrintf (_T("%#03x\n"), 1);
	2662
	2663	//wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
	2664
	2665	{
	2666	double d = FLT_MIN;
	2667	int niter = 17;
	2668
	2669	while (niter-- != 0)
	2670	wxPrintf (_T("%.17e\n"), d / 2);
	2671	fflush (stdout);
	2672	}
	2673
	2674	wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
	2675
	2676	#define FORMAT _T("\|%12.4f\|%12.4e\|%12.4g\|\n")
	2677	wxPrintf (FORMAT, 0.0, 0.0, 0.0);
	2678	wxPrintf (FORMAT, 1.0, 1.0, 1.0);
	2679	wxPrintf (FORMAT, -1.0, -1.0, -1.0);
	2680	wxPrintf (FORMAT, 100.0, 100.0, 100.0);
	2681	wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
	2682	wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
	2683	wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
	2684	wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
	2685	wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
	2686	#undef FORMAT
	2687
	2688	{
	2689	wxChar buf[20];
	2690	int rc = wxSnprintf (buf, WXSIZEOF(buf), _T("%30s"), _T("foo"));
	2691
	2692	wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
	2693	rc, WXSIZEOF(buf), buf);
	2694	#if 0
	2695	wxChar buf2[512];
	2696	wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
	2697	wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
	2698	#endif
	2699	}
	2700
	2701	fp_test ();
	2702
	2703	wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
	2704	wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
	2705	wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
	2706	wxPrintf (_T("%g should be 123.456\n"), 123.456);
	2707	wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
	2708	wxPrintf (_T("%g should be 10\n"), 10.0);
	2709	wxPrintf (_T("%g should be 0.02\n"), 0.02);
	2710
	2711	{
	2712	double x=1.0;
	2713	wxPrintf(_T("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
	2714	}
	2715
	2716	{
	2717	wxChar buf[200];
	2718
	2719	wxSprintf(buf,_T("%s%s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
	2720
	2721	result \|= wxStrcmp (buf,
	2722	_T("onetwo three "));
	2723
	2724	wxPuts (result != 0 ? _T("Test failed!") : _T("Test ok."));
	2725	}
	2726
	2727	#ifdef wxLongLong_t
	2728	{
	2729	wxChar buf[200];
	2730
	2731	wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
	2732	wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
	2733
	2734	if (wxStrcmp (buf, _T("40000000000")) != 0)
	2735	{
	2736	result = 1;
	2737	wxPuts (_T("\tFAILED"));
	2738	}
	2739	wxPuts (_T(""));
	2740	}
	2741	#endif // wxLongLong_t
	2742
	2743	wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
	2744	wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
	2745
	2746	wxPuts (_T("--- Should be no further output. ---"));
	2747	rfg1 ();
	2748	rfg2 ();
	2749
	2750	#if 0
	2751	{
	2752	wxChar bytes[7];
	2753	wxChar buf[20];
	2754
	2755	memset (bytes, '\xff', sizeof bytes);
	2756	wxSprintf (buf, _T("foo%hhn\n"), &bytes[3]);
	2757	if (bytes[0] != '\xff' \|\| bytes[1] != '\xff' \|\| bytes[2] != '\xff'
	2758	\|\| bytes[4] != '\xff' \|\| bytes[5] != '\xff' \|\| bytes[6] != '\xff')
	2759	{
	2760	wxPuts (_T("%hhn overwrite more bytes"));
	2761	result = 1;
	2762	}
	2763	if (bytes[3] != 3)
	2764	{
	2765	wxPuts (_T("%hhn wrote incorrect value"));
	2766	result = 1;
	2767	}
	2768	}
	2769	#endif
	2770	}
	2771
	2772	static void
	2773	rfg1 (void)
	2774	{
	2775	wxChar buf[100];
	2776
	2777	wxSprintf (buf, _T("%5.s"), _T("xyz"));
	2778	if (wxStrcmp (buf, _T(" ")) != 0)
	2779	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" "));
	2780	wxSprintf (buf, _T("%5.f"), 33.3);
	2781	if (wxStrcmp (buf, _T(" 33")) != 0)
	2782	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 33"));
	2783	wxSprintf (buf, _T("%8.e"), 33.3e7);
	2784	if (wxStrcmp (buf, _T(" 3e+08")) != 0)
	2785	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3e+08"));
	2786	wxSprintf (buf, _T("%8.E"), 33.3e7);
	2787	if (wxStrcmp (buf, _T(" 3E+08")) != 0)
	2788	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3E+08"));
	2789	wxSprintf (buf, _T("%.g"), 33.3);
	2790	if (wxStrcmp (buf, _T("3e+01")) != 0)
	2791	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3e+01"));
	2792	wxSprintf (buf, _T("%.G"), 33.3);
	2793	if (wxStrcmp (buf, _T("3E+01")) != 0)
	2794	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3E+01"));
	2795	}
	2796
	2797	static void
	2798	rfg2 (void)
	2799	{
	2800	int prec;
	2801	wxChar buf[100];
	2802
	2803	prec = 0;
	2804	wxSprintf (buf, _T("%.*g"), prec, 3.3);
	2805	if (wxStrcmp (buf, _T("3")) != 0)
	2806	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
	2807	prec = 0;
	2808	wxSprintf (buf, _T("%.*G"), prec, 3.3);
	2809	if (wxStrcmp (buf, _T("3")) != 0)
	2810	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
	2811	prec = 0;
	2812	wxSprintf (buf, _T("%7.*G"), prec, 3.33);
	2813	if (wxStrcmp (buf, _T(" 3")) != 0)
	2814	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3"));
	2815	prec = 3;
	2816	wxSprintf (buf, _T("%04.*o"), prec, 33);
	2817	if (wxStrcmp (buf, _T(" 041")) != 0)
	2818	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
	2819	prec = 7;
	2820	wxSprintf (buf, _T("%09.*u"), prec, 33);
	2821	if (wxStrcmp (buf, _T(" 0000033")) != 0)
	2822	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 0000033"));
	2823	prec = 3;
	2824	wxSprintf (buf, _T("%04.*x"), prec, 33);
	2825	if (wxStrcmp (buf, _T(" 021")) != 0)
	2826	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
	2827	prec = 3;
	2828	wxSprintf (buf, _T("%04.*X"), prec, 33);
	2829	if (wxStrcmp (buf, _T(" 021")) != 0)
	2830	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
	2831	}
	2832
	2833	#endif // TEST_PRINTF
	2834
	2835	// ----------------------------------------------------------------------------
	2836	// registry and related stuff
	2837	// ----------------------------------------------------------------------------
	2838
	2839	// this is for MSW only
	2840	#ifndef __WXMSW__
	2841	#undef TEST_REGCONF
	2842	#undef TEST_REGISTRY
	2843	#endif
	2844
	2845	#ifdef TEST_REGCONF
	2846
	2847	#include "wx/confbase.h"
	2848	#include "wx/msw/regconf.h"
	2849
	2850	static void TestRegConfWrite()
	2851	{
	2852	wxRegConfig regconf(_T("console"), _T("wxwindows"));
	2853	regconf.Write(_T("Hello"), wxString(_T("world")));
	2854	}
	2855
	2856	#endif // TEST_REGCONF
	2857
	2858	#ifdef TEST_REGISTRY
	2859
	2860	#include "wx/msw/registry.h"
	2861
	2862	// I chose this one because I liked its name, but it probably only exists under
	2863	// NT
	2864	static const wxChar *TESTKEY =
	2865	_T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
	2866
	2867	static void TestRegistryRead()
	2868	{
	2869	wxPuts(_T("* testing registry reading *"));
	2870
	2871	wxRegKey key(TESTKEY);
	2872	wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
	2873	if ( !key.Open() )
	2874	{
	2875	wxPuts(_T("ERROR: test key can't be opened, aborting test."));
	2876
	2877	return;
	2878	}
	2879
	2880	size_t nSubKeys, nValues;
	2881	if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
	2882	{
	2883	wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
	2884	}
	2885
	2886	wxPrintf(_T("Enumerating values:\n"));
	2887
	2888	long dummy;
	2889	wxString value;
	2890	bool cont = key.GetFirstValue(value, dummy);
	2891	while ( cont )
	2892	{
	2893	wxPrintf(_T("Value '%s': type "), value.c_str());
	2894	switch ( key.GetValueType(value) )
	2895	{
	2896	case wxRegKey::Type_None: wxPrintf(_T("ERROR (none)")); break;
	2897	case wxRegKey::Type_String: wxPrintf(_T("SZ")); break;
	2898	case wxRegKey::Type_Expand_String: wxPrintf(_T("EXPAND_SZ")); break;
	2899	case wxRegKey::Type_Binary: wxPrintf(_T("BINARY")); break;
	2900	case wxRegKey::Type_Dword: wxPrintf(_T("DWORD")); break;
	2901	case wxRegKey::Type_Multi_String: wxPrintf(_T("MULTI_SZ")); break;
	2902	default: wxPrintf(_T("other (unknown)")); break;
	2903	}
	2904
	2905	wxPrintf(_T(", value = "));
	2906	if ( key.IsNumericValue(value) )
	2907	{
	2908	long val;
	2909	key.QueryValue(value, &val);
	2910	wxPrintf(_T("%ld"), val);
	2911	}
	2912	else // string
	2913	{
	2914	wxString val;
	2915	key.QueryValue(value, val);
	2916	wxPrintf(_T("'%s'"), val.c_str());
	2917
	2918	key.QueryRawValue(value, val);
	2919	wxPrintf(_T(" (raw value '%s')"), val.c_str());
	2920	}
	2921
	2922	putchar('\n');
	2923
	2924	cont = key.GetNextValue(value, dummy);
	2925	}
	2926	}
	2927
	2928	static void TestRegistryAssociation()
	2929	{
	2930	/*
	2931	The second call to deleteself genertaes an error message, with a
	2932	messagebox saying .flo is crucial to system operation, while the .ddf
	2933	call also fails, but with no error message
	2934	*/
	2935
	2936	wxRegKey key;
	2937
	2938	key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
	2939	key.Create();
	2940	key = "ddxf_auto_file" ;
	2941	key.SetName("HKEY_CLASSES_ROOT\\.flo" );
	2942	key.Create();
	2943	key = "ddxf_auto_file" ;
	2944	key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
	2945	key.Create();
	2946	key = "program,0" ;
	2947	key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
	2948	key.Create();
	2949	key = "program \"%1\"" ;
	2950
	2951	key.SetName("HKEY_CLASSES_ROOT\\.ddf" );
	2952	key.DeleteSelf();
	2953	key.SetName("HKEY_CLASSES_ROOT\\.flo" );
	2954	key.DeleteSelf();
	2955	key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon");
	2956	key.DeleteSelf();
	2957	key.SetName("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command");
	2958	key.DeleteSelf();
	2959	}
	2960
	2961	#endif // TEST_REGISTRY
	2962
	2963	// ----------------------------------------------------------------------------
	2964	// sockets
	2965	// ----------------------------------------------------------------------------
	2966
	2967	#ifdef TEST_SOCKETS
	2968
	2969	#include "wx/socket.h"
	2970	#include "wx/protocol/protocol.h"
	2971	#include "wx/protocol/http.h"
	2972
	2973	static void TestSocketServer()
	2974	{
	2975	wxPuts(_T("* Testing wxSocketServer *\n"));
	2976
	2977	static const int PORT = 3000;
	2978
	2979	wxIPV4address addr;
	2980	addr.Service(PORT);
	2981
	2982	wxSocketServer *server = new wxSocketServer(addr);
	2983	if ( !server->Ok() )
	2984	{
	2985	wxPuts(_T("ERROR: failed to bind"));
	2986
	2987	return;
	2988	}
	2989
	2990	for ( ;; )
	2991	{
	2992	wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
	2993
	2994	wxSocketBase *socket = server->Accept();
	2995	if ( !socket )
	2996	{
	2997	wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
	2998	break;
	2999	}
	3000
	3001	wxPuts(_T("Server: got a client."));
	3002
	3003	server->SetTimeout(60); // 1 min
	3004
	3005	while ( socket->IsConnected() )
	3006	{
	3007	wxString s;
	3008	wxChar ch = _T('\0');
	3009	for ( ;; )
	3010	{
	3011	if ( socket->Read(&ch, sizeof(ch)).Error() )
	3012	{
	3013	// don't log error if the client just close the connection
	3014	if ( socket->IsConnected() )
	3015	{
	3016	wxPuts(_T("ERROR: in wxSocket::Read."));
	3017	}
	3018
	3019	break;
	3020	}
	3021
	3022	if ( ch == '\r' )
	3023	continue;
	3024
	3025	if ( ch == '\n' )
	3026	break;
	3027
	3028	s += ch;
	3029	}
	3030
	3031	if ( ch != '\n' )
	3032	{
	3033	break;
	3034	}
	3035
	3036	wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
	3037	if ( s == _T("bye") )
	3038	{
	3039	delete socket;
	3040
	3041	break;
	3042	}
	3043
	3044	socket->Write(s.MakeUpper().c_str(), s.length());
	3045	socket->Write("\r\n", 2);
	3046	wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
	3047	}
	3048
	3049	wxPuts(_T("Server: lost a client."));
	3050
	3051	socket->Destroy();
	3052	}
	3053
	3054	// same as "delete server" but is consistent with GUI programs
	3055	server->Destroy();
	3056	}
	3057
	3058	static void TestSocketClient()
	3059	{
	3060	wxPuts(_T("* Testing wxSocketClient *\n"));
	3061
	3062	static const wxChar *hostname = _T("www.wxwindows.org");
	3063
	3064	wxIPV4address addr;
	3065	addr.Hostname(hostname);
	3066	addr.Service(80);
	3067
	3068	wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
	3069
	3070	wxSocketClient client;
	3071	if ( !client.Connect(addr) )
	3072	{
	3073	wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
	3074	}
	3075	else
	3076	{
	3077	wxPrintf(_T("--- Connected to %s:%u...\n"),
	3078	addr.Hostname().c_str(), addr.Service());
	3079
	3080	wxChar buf[8192];
	3081
	3082	// could use simply "GET" here I suppose
	3083	wxString cmdGet =
	3084	wxString::Format(_T("GET http://%s/\r\n"), hostname);
	3085	client.Write(cmdGet, cmdGet.length());
	3086	wxPrintf(_T("--- Sent command '%s' to the server\n"),
	3087	MakePrintable(cmdGet).c_str());
	3088	client.Read(buf, WXSIZEOF(buf));
	3089	wxPrintf(_T("--- Server replied:\n%s"), buf);
	3090	}
	3091	}
	3092
	3093	#endif // TEST_SOCKETS
	3094
	3095	// ----------------------------------------------------------------------------
	3096	// FTP
	3097	// ----------------------------------------------------------------------------
	3098
	3099	#ifdef TEST_FTP
	3100
	3101	#include "wx/protocol/ftp.h"
	3102
	3103	static wxFTP ftp;
	3104
	3105	#define FTP_ANONYMOUS
	3106
	3107	#ifdef FTP_ANONYMOUS
	3108	static const wxChar *directory = _T("/pub");
	3109	static const wxChar *filename = _T("welcome.msg");
	3110	#else
	3111	static const wxChar *directory = _T("/etc");
	3112	static const wxChar *filename = _T("issue");
	3113	#endif
	3114
	3115	static bool TestFtpConnect()
	3116	{
	3117	wxPuts(_T("* Testing FTP connect *"));
	3118
	3119	#ifdef FTP_ANONYMOUS
	3120	static const wxChar *hostname = _T("ftp.wxwindows.org");
	3121
	3122	wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
	3123	#else // !FTP_ANONYMOUS
	3124	static const wxChar *hostname = "localhost";
	3125
	3126	wxChar user[256];
	3127	wxFgets(user, WXSIZEOF(user), stdin);
	3128	user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
	3129	ftp.SetUser(user);
	3130
	3131	wxChar password[256];
	3132	wxPrintf(_T("Password for %s: "), password);
	3133	wxFgets(password, WXSIZEOF(password), stdin);
	3134	password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
	3135	ftp.SetPassword(password);
	3136
	3137	wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
	3138	#endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
	3139
	3140	if ( !ftp.Connect(hostname) )
	3141	{
	3142	wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
	3143
	3144	return FALSE;
	3145	}
	3146	else
	3147	{
	3148	wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
	3149	hostname, ftp.Pwd().c_str());
	3150	}
	3151
	3152	return TRUE;
	3153	}
	3154
	3155	// test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
	3156	static void TestFtpWuFtpd()
	3157	{
	3158	wxFTP ftp;
	3159	static const wxChar *hostname = _T("ftp.eudora.com");
	3160	if ( !ftp.Connect(hostname) )
	3161	{
	3162	wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
	3163	}
	3164	else
	3165	{
	3166	static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
	3167	wxInputStream *in = ftp.GetInputStream(filename);
	3168	if ( !in )
	3169	{
	3170	wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
	3171	}
	3172	else
	3173	{
	3174	size_t size = in->GetSize();
	3175	wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
	3176
	3177	wxChar *data = new wxChar[size];
	3178	if ( !in->Read(data, size) )
	3179	{
	3180	wxPuts(_T("ERROR: read error"));
	3181	}
	3182	else
	3183	{
	3184	wxPrintf(_T("Successfully retrieved the file.\n"));
	3185	}
	3186
	3187	delete [] data;
	3188	delete in;
	3189	}
	3190	}
	3191	}
	3192
	3193	static void TestFtpList()
	3194	{
	3195	wxPuts(_T("* Testing wxFTP file listing *\n"));
	3196
	3197	// test CWD
	3198	if ( !ftp.ChDir(directory) )
	3199	{
	3200	wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
	3201	}
	3202
	3203	wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
	3204
	3205	// test NLIST and LIST
	3206	wxArrayString files;
	3207	if ( !ftp.GetFilesList(files) )
	3208	{
	3209	wxPuts(_T("ERROR: failed to get NLIST of files"));
	3210	}
	3211	else
	3212	{
	3213	wxPrintf(_T("Brief list of files under '%s':\n"), ftp.Pwd().c_str());
	3214	size_t count = files.GetCount();
	3215	for ( size_t n = 0; n < count; n++ )
	3216	{
	3217	wxPrintf(_T("\t%s\n"), files[n].c_str());
	3218	}
	3219	wxPuts(_T("End of the file list"));
	3220	}
	3221
	3222	if ( !ftp.GetDirList(files) )
	3223	{
	3224	wxPuts(_T("ERROR: failed to get LIST of files"));
	3225	}
	3226	else
	3227	{
	3228	wxPrintf(_T("Detailed list of files under '%s':\n"), ftp.Pwd().c_str());
	3229	size_t count = files.GetCount();
	3230	for ( size_t n = 0; n < count; n++ )
	3231	{
	3232	wxPrintf(_T("\t%s\n"), files[n].c_str());
	3233	}
	3234	wxPuts(_T("End of the file list"));
	3235	}
	3236
	3237	if ( !ftp.ChDir(_T("..")) )
	3238	{
	3239	wxPuts(_T("ERROR: failed to cd to .."));
	3240	}
	3241
	3242	wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
	3243	}
	3244
	3245	static void TestFtpDownload()
	3246	{
	3247	wxPuts(_T("* Testing wxFTP download *\n"));
	3248
	3249	// test RETR
	3250	wxInputStream *in = ftp.GetInputStream(filename);
	3251	if ( !in )
	3252	{
	3253	wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
	3254	}
	3255	else
	3256	{
	3257	size_t size = in->GetSize();
	3258	wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
	3259	fflush(stdout);
	3260
	3261	wxChar *data = new wxChar[size];
	3262	if ( !in->Read(data, size) )
	3263	{
	3264	wxPuts(_T("ERROR: read error"));
	3265	}
	3266	else
	3267	{
	3268	wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
	3269	}
	3270
	3271	delete [] data;
	3272	delete in;
	3273	}
	3274	}
	3275
	3276	static void TestFtpFileSize()
	3277	{
	3278	wxPuts(_T("* Testing FTP SIZE command *"));
	3279
	3280	if ( !ftp.ChDir(directory) )
	3281	{
	3282	wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
	3283	}
	3284
	3285	wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
	3286
	3287	if ( ftp.FileExists(filename) )
	3288	{
	3289	int size = ftp.GetFileSize(filename);
	3290	if ( size == -1 )
	3291	wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
	3292	else
	3293	wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
	3294	}
	3295	else
	3296	{
	3297	wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
	3298	}
	3299	}
	3300
	3301	static void TestFtpMisc()
	3302	{
	3303	wxPuts(_T("* Testing miscellaneous wxFTP functions *"));
	3304
	3305	if ( ftp.SendCommand("STAT") != '2' )
	3306	{
	3307	wxPuts(_T("ERROR: STAT failed"));
	3308	}
	3309	else
	3310	{
	3311	wxPrintf(_T("STAT returned:\n\n%s\n"), ftp.GetLastResult().c_str());
	3312	}
	3313
	3314	if ( ftp.SendCommand("HELP SITE") != '2' )
	3315	{
	3316	wxPuts(_T("ERROR: HELP SITE failed"));
	3317	}
	3318	else
	3319	{
	3320	wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
	3321	ftp.GetLastResult().c_str());
	3322	}
	3323	}
	3324
	3325	static void TestFtpInteractive()
	3326	{
	3327	wxPuts(_T("\n* Interactive wxFTP test *"));
	3328
	3329	wxChar buf[128];
	3330
	3331	for ( ;; )
	3332	{
	3333	wxPrintf(_T("Enter FTP command: "));
	3334	if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
	3335	break;
	3336
	3337	// kill the last '\n'
	3338	buf[wxStrlen(buf) - 1] = 0;
	3339
	3340	// special handling of LIST and NLST as they require data connection
	3341	wxString start(buf, 4);
	3342	start.MakeUpper();
	3343	if ( start == "LIST" \|\| start == "NLST" )
	3344	{
	3345	wxString wildcard;
	3346	if ( wxStrlen(buf) > 4 )
	3347	wildcard = buf + 5;
	3348
	3349	wxArrayString files;
	3350	if ( !ftp.GetList(files, wildcard, start == "LIST") )
	3351	{
	3352	wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
	3353	}
	3354	else
	3355	{
	3356	wxPrintf(_T("--- %s of '%s' under '%s':\n"),
	3357	start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
	3358	size_t count = files.GetCount();
	3359	for ( size_t n = 0; n < count; n++ )
	3360	{
	3361	wxPrintf(_T("\t%s\n"), files[n].c_str());
	3362	}
	3363	wxPuts(_T("--- End of the file list"));
	3364	}
	3365	}
	3366	else // !list
	3367	{
	3368	wxChar ch = ftp.SendCommand(buf);
	3369	wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
	3370	if ( ch )
	3371	{
	3372	wxPrintf(_T(" (return code %c)"), ch);
	3373	}
	3374
	3375	wxPrintf(_T(", server reply:\n%s\n\n"), ftp.GetLastResult().c_str());
	3376	}
	3377	}
	3378
	3379	wxPuts(_T("\n* done *"));
	3380	}
	3381
	3382	static void TestFtpUpload()
	3383	{
	3384	wxPuts(_T("* Testing wxFTP uploading *\n"));
	3385
	3386	// upload a file
	3387	static const wxChar *file1 = _T("test1");
	3388	static const wxChar *file2 = _T("test2");
	3389	wxOutputStream *out = ftp.GetOutputStream(file1);
	3390	if ( out )
	3391	{
	3392	wxPrintf(_T("--- Uploading to %s ---\n"), file1);
	3393	out->Write("First hello", 11);
	3394	delete out;
	3395	}
	3396
	3397	// send a command to check the remote file
	3398	if ( ftp.SendCommand(wxString("STAT ") + file1) != '2' )
	3399	{
	3400	wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
	3401	}
	3402	else
	3403	{
	3404	wxPrintf(_T("STAT %s returned:\n\n%s\n"),
	3405	file1, ftp.GetLastResult().c_str());
	3406	}
	3407
	3408	out = ftp.GetOutputStream(file2);
	3409	if ( out )
	3410	{
	3411	wxPrintf(_T("--- Uploading to %s ---\n"), file1);
	3412	out->Write("Second hello", 12);
	3413	delete out;
	3414	}
	3415	}
	3416
	3417	#endif // TEST_FTP
	3418
	3419	// ----------------------------------------------------------------------------
	3420	// streams
	3421	// ----------------------------------------------------------------------------
	3422
	3423	#ifdef TEST_STREAMS
	3424
	3425	#include "wx/wfstream.h"
	3426	#include "wx/mstream.h"
	3427
	3428	static void TestFileStream()
	3429	{
	3430	wxPuts(_T("* Testing wxFileInputStream *"));
	3431
	3432	static const wxChar *filename = _T("testdata.fs");
	3433	{
	3434	wxFileOutputStream fsOut(filename);
	3435	fsOut.Write("foo", 3);
	3436	}
	3437
	3438	wxFileInputStream fsIn(filename);
	3439	wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
	3440	while ( !fsIn.Eof() )
	3441	{
	3442	putchar(fsIn.GetC());
	3443	}
	3444
	3445	if ( !wxRemoveFile(filename) )
	3446	{
	3447	wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename);
	3448	}
	3449
	3450	wxPuts(_T("\n* wxFileInputStream test done *"));
	3451	}
	3452
	3453	static void TestMemoryStream()
	3454	{
	3455	wxPuts(_T("* Testing wxMemoryOutputStream *"));
	3456
	3457	wxMemoryOutputStream memOutStream;
	3458	wxPrintf(_T("Initially out stream offset: %lu\n"),
	3459	(unsigned long)memOutStream.TellO());
	3460
	3461	for ( const wxChar p = _T("Hello, stream!"); p; p++ )
	3462	{
	3463	memOutStream.PutC(*p);
	3464	}
	3465
	3466	wxPrintf(_T("Final out stream offset: %lu\n"),
	3467	(unsigned long)memOutStream.TellO());
	3468
	3469	wxPuts(_T("* Testing wxMemoryInputStream *"));
	3470
	3471	wxChar buf[1024];
	3472	size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
	3473
	3474	wxMemoryInputStream memInpStream(buf, len);
	3475	wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
	3476	while ( !memInpStream.Eof() )
	3477	{
	3478	putchar(memInpStream.GetC());
	3479	}
	3480
	3481	wxPuts(_T("\n* wxMemoryInputStream test done *"));
	3482	}
	3483
	3484	#endif // TEST_STREAMS
	3485
	3486	// ----------------------------------------------------------------------------
	3487	// timers
	3488	// ----------------------------------------------------------------------------
	3489
	3490	#ifdef TEST_TIMER
	3491
	3492	#include "wx/timer.h"
	3493	#include "wx/utils.h"
	3494
	3495	static void TestStopWatch()
	3496	{
	3497	wxPuts(_T("* Testing wxStopWatch *\n"));
	3498
	3499	wxStopWatch sw;
	3500	sw.Pause();
	3501	wxPrintf(_T("Initially paused, after 2 seconds time is..."));
	3502	fflush(stdout);
	3503	wxSleep(2);
	3504	wxPrintf(_T("\t%ldms\n"), sw.Time());
	3505
	3506	wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
	3507	fflush(stdout);
	3508	sw.Resume();
	3509	wxSleep(3);
	3510	wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
	3511
	3512	sw.Pause();
	3513	wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
	3514	fflush(stdout);
	3515	wxSleep(2);
	3516	wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
	3517
	3518	sw.Resume();
	3519	wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
	3520	fflush(stdout);
	3521	wxSleep(2);
	3522	wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
	3523
	3524	wxStopWatch sw2;
	3525	wxPuts(_T("\nChecking for 'backwards clock' bug..."));
	3526	for ( size_t n = 0; n < 70; n++ )
	3527	{
	3528	sw2.Start();
	3529
	3530	for ( size_t m = 0; m < 100000; m++ )
	3531	{
	3532	if ( sw.Time() < 0 \|\| sw2.Time() < 0 )
	3533	{
	3534	wxPuts(_T("\ntime is negative - ERROR!"));
	3535	}
	3536	}
	3537
	3538	putchar('.');
	3539	fflush(stdout);
	3540	}
	3541
	3542	wxPuts(_T(", ok."));
	3543	}
	3544
	3545	#endif // TEST_TIMER
	3546
	3547	// ----------------------------------------------------------------------------
	3548	// vCard support
	3549	// ----------------------------------------------------------------------------
	3550
	3551	#ifdef TEST_VCARD
	3552
	3553	#include "wx/vcard.h"
	3554
	3555	static void DumpVObject(size_t level, const wxVCardObject& vcard)
	3556	{
	3557	void *cookie;
	3558	wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
	3559	while ( vcObj )
	3560	{
	3561	wxPrintf(_T("%s%s"),
	3562	wxString(_T('\t'), level).c_str(),
	3563	vcObj->GetName().c_str());
	3564
	3565	wxString value;
	3566	switch ( vcObj->GetType() )
	3567	{
	3568	case wxVCardObject::String:
	3569	case wxVCardObject::UString:
	3570	{
	3571	wxString val;
	3572	vcObj->GetValue(&val);
	3573	value << _T('"') << val << _T('"');
	3574	}
	3575	break;
	3576
	3577	case wxVCardObject::Int:
	3578	{
	3579	unsigned int i;
	3580	vcObj->GetValue(&i);
	3581	value.Printf(_T("%u"), i);
	3582	}
	3583	break;
	3584
	3585	case wxVCardObject::Long:
	3586	{
	3587	unsigned long l;
	3588	vcObj->GetValue(&l);
	3589	value.Printf(_T("%lu"), l);
	3590	}
	3591	break;
	3592
	3593	case wxVCardObject::None:
	3594	break;
	3595
	3596	case wxVCardObject::Object:
	3597	value = _T("<node>");
	3598	break;
	3599
	3600	default:
	3601	value = _T("<unknown value type>");
	3602	}
	3603
	3604	if ( !!value )
	3605	wxPrintf(_T(" = %s"), value.c_str());
	3606	putchar('\n');
	3607
	3608	DumpVObject(level + 1, *vcObj);
	3609
	3610	delete vcObj;
	3611	vcObj = vcard.GetNextProp(&cookie);
	3612	}
	3613	}
	3614
	3615	static void DumpVCardAddresses(const wxVCard& vcard)
	3616	{
	3617	wxPuts(_T("\nShowing all addresses from vCard:\n"));
	3618
	3619	size_t nAdr = 0;
	3620	void *cookie;
	3621	wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
	3622	while ( addr )
	3623	{
	3624	wxString flagsStr;
	3625	int flags = addr->GetFlags();
	3626	if ( flags & wxVCardAddress::Domestic )
	3627	{
	3628	flagsStr << _T("domestic ");
	3629	}
	3630	if ( flags & wxVCardAddress::Intl )
	3631	{
	3632	flagsStr << _T("international ");
	3633	}
	3634	if ( flags & wxVCardAddress::Postal )
	3635	{
	3636	flagsStr << _T("postal ");
	3637	}
	3638	if ( flags & wxVCardAddress::Parcel )
	3639	{
	3640	flagsStr << _T("parcel ");
	3641	}
	3642	if ( flags & wxVCardAddress::Home )
	3643	{
	3644	flagsStr << _T("home ");
	3645	}
	3646	if ( flags & wxVCardAddress::Work )
	3647	{
	3648	flagsStr << _T("work ");
	3649	}
	3650
	3651	wxPrintf(_T("Address %u:\n")
	3652	"\tflags = %s\n"
	3653	"\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
	3654	++nAdr,
	3655	flagsStr.c_str(),
	3656	addr->GetPostOffice().c_str(),
	3657	addr->GetExtAddress().c_str(),
	3658	addr->GetStreet().c_str(),
	3659	addr->GetLocality().c_str(),
	3660	addr->GetRegion().c_str(),
	3661	addr->GetPostalCode().c_str(),
	3662	addr->GetCountry().c_str()
	3663	);
	3664
	3665	delete addr;
	3666	addr = vcard.GetNextAddress(&cookie);
	3667	}
	3668	}
	3669
	3670	static void DumpVCardPhoneNumbers(const wxVCard& vcard)
	3671	{
	3672	wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
	3673
	3674	size_t nPhone = 0;
	3675	void *cookie;
	3676	wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
	3677	while ( phone )
	3678	{
	3679	wxString flagsStr;
	3680	int flags = phone->GetFlags();
	3681	if ( flags & wxVCardPhoneNumber::Voice )
	3682	{
	3683	flagsStr << _T("voice ");
	3684	}
	3685	if ( flags & wxVCardPhoneNumber::Fax )
	3686	{
	3687	flagsStr << _T("fax ");
	3688	}
	3689	if ( flags & wxVCardPhoneNumber::Cellular )
	3690	{
	3691	flagsStr << _T("cellular ");
	3692	}
	3693	if ( flags & wxVCardPhoneNumber::Modem )
	3694	{
	3695	flagsStr << _T("modem ");
	3696	}
	3697	if ( flags & wxVCardPhoneNumber::Home )
	3698	{
	3699	flagsStr << _T("home ");
	3700	}
	3701	if ( flags & wxVCardPhoneNumber::Work )
	3702	{
	3703	flagsStr << _T("work ");
	3704	}
	3705
	3706	wxPrintf(_T("Phone number %u:\n")
	3707	"\tflags = %s\n"
	3708	"\tvalue = %s\n",
	3709	++nPhone,
	3710	flagsStr.c_str(),
	3711	phone->GetNumber().c_str()
	3712	);
	3713
	3714	delete phone;
	3715	phone = vcard.GetNextPhoneNumber(&cookie);
	3716	}
	3717	}
	3718
	3719	static void TestVCardRead()
	3720	{
	3721	wxPuts(_T("* Testing wxVCard reading *\n"));
	3722
	3723	wxVCard vcard(_T("vcard.vcf"));
	3724	if ( !vcard.IsOk() )
	3725	{
	3726	wxPuts(_T("ERROR: couldn't load vCard."));
	3727	}
	3728	else
	3729	{
	3730	// read individual vCard properties
	3731	wxVCardObject *vcObj = vcard.GetProperty("FN");
	3732	wxString value;
	3733	if ( vcObj )
	3734	{
	3735	vcObj->GetValue(&value);
	3736	delete vcObj;
	3737	}
	3738	else
	3739	{
	3740	value = _T("<none>");
	3741	}
	3742
	3743	wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
	3744
	3745
	3746	if ( !vcard.GetFullName(&value) )
	3747	{
	3748	value = _T("<none>");
	3749	}
	3750
	3751	wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
	3752
	3753	// now show how to deal with multiply occuring properties
	3754	DumpVCardAddresses(vcard);
	3755	DumpVCardPhoneNumbers(vcard);
	3756
	3757	// and finally show all
	3758	wxPuts(_T("\nNow dumping the entire vCard:\n")
	3759	"-----------------------------\n");
	3760
	3761	DumpVObject(0, vcard);
	3762	}
	3763	}
	3764
	3765	static void TestVCardWrite()
	3766	{
	3767	wxPuts(_T("* Testing wxVCard writing *\n"));
	3768
	3769	wxVCard vcard;
	3770	if ( !vcard.IsOk() )
	3771	{
	3772	wxPuts(_T("ERROR: couldn't create vCard."));
	3773	}
	3774	else
	3775	{
	3776	// set some fields
	3777	vcard.SetName("Zeitlin", "Vadim");
	3778	vcard.SetFullName("Vadim Zeitlin");
	3779	vcard.SetOrganization("wxWindows", "R&D");
	3780
	3781	// just dump the vCard back
	3782	wxPuts(_T("Entire vCard follows:\n"));
	3783	wxPuts(vcard.Write());
	3784	}
	3785	}
	3786
	3787	#endif // TEST_VCARD
	3788
	3789	// ----------------------------------------------------------------------------
	3790	// wxVolume tests
	3791	// ----------------------------------------------------------------------------
	3792
	3793	#if !defined(__WIN32__) \|\| !wxUSE_FSVOLUME
	3794	#undef TEST_VOLUME
	3795	#endif
	3796
	3797	#ifdef TEST_VOLUME
	3798
	3799	#include "wx/volume.h"
	3800
	3801	static const wxChar *volumeKinds[] =
	3802	{
	3803	_T("floppy"),
	3804	_T("hard disk"),
	3805	_T("CD-ROM"),
	3806	_T("DVD-ROM"),
	3807	_T("network volume"),
	3808	_T("other volume"),
	3809	};
	3810
	3811	static void TestFSVolume()
	3812	{
	3813	wxPuts(_T("* Testing wxFSVolume class *"));
	3814
	3815	wxArrayString volumes = wxFSVolume::GetVolumes();
	3816	size_t count = volumes.GetCount();
	3817
	3818	if ( !count )
	3819	{
	3820	wxPuts(_T("ERROR: no mounted volumes?"));
	3821	return;
	3822	}
	3823
	3824	wxPrintf(_T("%u mounted volumes found:\n"), count);
	3825
	3826	for ( size_t n = 0; n < count; n++ )
	3827	{
	3828	wxFSVolume vol(volumes[n]);
	3829	if ( !vol.IsOk() )
	3830	{
	3831	wxPuts(_T("ERROR: couldn't create volume"));
	3832	continue;
	3833	}
	3834
	3835	wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
	3836	n + 1,
	3837	vol.GetDisplayName().c_str(),
	3838	vol.GetName().c_str(),
	3839	volumeKinds[vol.GetKind()],
	3840	vol.IsWritable() ? _T("rw") : _T("ro"),
	3841	vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
	3842	: _T("fixed"));
	3843	}
	3844	}
	3845
	3846	#endif // TEST_VOLUME
	3847
	3848	// ----------------------------------------------------------------------------
	3849	// wide char and Unicode support
	3850	// ----------------------------------------------------------------------------
	3851
	3852	#ifdef TEST_UNICODE
	3853
	3854	static void TestUnicodeToFromAscii()
	3855	{
	3856	wxPuts(_T("Testing wxString::To/FromAscii()\n"));
	3857
	3858	static const char *msg = "Hello, world!";
	3859	wxString s = wxString::FromAscii(msg);
	3860
	3861	wxPrintf(_T("Message in Unicode: %s\n"), s.c_str());
	3862	printf("Message in ASCII: %s\n", (const char *)s.ToAscii());
	3863
	3864	wxPutchar(_T('\n'));
	3865	}
	3866
	3867	#endif // TEST_UNICODE
	3868
	3869	#ifdef TEST_WCHAR
	3870
	3871	#include "wx/strconv.h"
	3872	#include "wx/fontenc.h"
	3873	#include "wx/encconv.h"
	3874	#include "wx/buffer.h"
	3875
	3876	static const unsigned char utf8koi8r[] =
	3877	{
	3878	208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
	3879	208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
	3880	176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
	3881	208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
	3882	181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
	3883	208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
	3884	178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
	3885	};
	3886
	3887	static const unsigned char utf8iso8859_1[] =
	3888	{
	3889	0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
	3890	0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
	3891	0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
	3892	0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
	3893	0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
	3894	};
	3895
	3896	static const unsigned char utf8Invalid[] =
	3897	{
	3898	0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
	3899	0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
	3900	0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
	3901	0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
	3902	0x6c, 0x61, 0x79, 0
	3903	};
	3904
	3905	static const struct Utf8Data
	3906	{
	3907	const unsigned char *text;
	3908	size_t len;
	3909	const wxChar *charset;
	3910	wxFontEncoding encoding;
	3911	} utf8data[] =
	3912	{
	3913	{ utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
	3914	{ utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
	3915	{ utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
	3916	};
	3917
	3918	static void TestUtf8()
	3919	{
	3920	wxPuts(_T("* Testing UTF8 support *\n"));
	3921
	3922	char buf[1024];
	3923	wchar_t wbuf[1024];
	3924
	3925	for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
	3926	{
	3927	const Utf8Data& u8d = utf8data[n];
	3928	if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
	3929	WXSIZEOF(wbuf)) == (size_t)-1 )
	3930	{
	3931	wxPuts(_T("ERROR: UTF-8 decoding failed."));
	3932	}
	3933	else
	3934	{
	3935	wxCSConv conv(u8d.charset);
	3936	if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
	3937	{
	3938	wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
	3939	}
	3940	else
	3941	{
	3942	wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
	3943	}
	3944	}
	3945
	3946	wxString s(wxConvUTF8.cMB2WC((const char )u8d.text), wxConvCurrent);
	3947	if ( s.empty() )
	3948	s = _T("<< conversion failed >>");
	3949	wxPrintf(_T("String in current cset: %s\n"), s.c_str());
	3950
	3951	}
	3952
	3953	wxPuts(_T(""));
	3954	}
	3955
	3956	static void TestEncodingConverter()
	3957	{
	3958	wxPuts(_T("* Testing wxEncodingConverter *\n"));
	3959
	3960	// using wxEncodingConverter should give the same result as above
	3961	char buf[1024];
	3962	wchar_t wbuf[1024];
	3963	if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
	3964	WXSIZEOF(utf8koi8r)) == (size_t)-1 )
	3965	{
	3966	wxPuts(_T("ERROR: UTF-8 decoding failed."));
	3967	}
	3968	else
	3969	{
	3970	wxEncodingConverter ec;
	3971	ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
	3972	ec.Convert(wbuf, buf);
	3973	wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
	3974	}
	3975
	3976	wxPuts(_T(""));
	3977	}
	3978
	3979	#endif // TEST_WCHAR
	3980
	3981	// ----------------------------------------------------------------------------
	3982	// ZIP stream
	3983	// ----------------------------------------------------------------------------
	3984
	3985	#ifdef TEST_ZIP
	3986
	3987	#include "wx/filesys.h"
	3988	#include "wx/fs_zip.h"
	3989	#include "wx/zipstrm.h"
	3990
	3991	static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
	3992
	3993	static void TestZipStreamRead()
	3994	{
	3995	wxPuts(_T("* Testing ZIP reading *\n"));
	3996
	3997	static const wxChar *filename = _T("foo");
	3998	wxZipInputStream istr(TESTFILE_ZIP, filename);
	3999	wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
	4000
	4001	wxPrintf(_T("Dumping the file '%s':\n"), filename);
	4002	while ( !istr.Eof() )
	4003	{
	4004	putchar(istr.GetC());
	4005	fflush(stdout);
	4006	}
	4007
	4008	wxPuts(_T("\n----- done ------"));
	4009	}
	4010
	4011	static void DumpZipDirectory(wxFileSystem& fs,
	4012	const wxString& dir,
	4013	const wxString& indent)
	4014	{
	4015	wxString prefix = wxString::Format(_T("%s#zip:%s"),
	4016	TESTFILE_ZIP, dir.c_str());
	4017	wxString wildcard = prefix + _T("/*");
	4018
	4019	wxString dirname = fs.FindFirst(wildcard, wxDIR);
	4020	while ( !dirname.empty() )
	4021	{
	4022	if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
	4023	{
	4024	wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
	4025
	4026	break;
	4027	}
	4028
	4029	wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
	4030
	4031	DumpZipDirectory(fs, dirname,
	4032	indent + wxString(_T(' '), 4));
	4033
	4034	dirname = fs.FindNext();
	4035	}
	4036
	4037	wxString filename = fs.FindFirst(wildcard, wxFILE);
	4038	while ( !filename.empty() )
	4039	{
	4040	if ( !filename.StartsWith(prefix, &filename) )
	4041	{
	4042	wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
	4043
	4044	break;
	4045	}
	4046
	4047	wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
	4048
	4049	filename = fs.FindNext();
	4050	}
	4051	}
	4052
	4053	static void TestZipFileSystem()
	4054	{
	4055	wxPuts(_T("* Testing ZIP file system *\n"));
	4056
	4057	wxFileSystem::AddHandler(new wxZipFSHandler);
	4058	wxFileSystem fs;
	4059	wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
	4060
	4061	DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
	4062	}
	4063
	4064	#endif // TEST_ZIP
	4065
	4066	// ----------------------------------------------------------------------------
	4067	// ZLIB stream
	4068	// ----------------------------------------------------------------------------
	4069
	4070	#ifdef TEST_ZLIB
	4071
	4072	#include "wx/zstream.h"
	4073	#include "wx/wfstream.h"
	4074
	4075	static const wxChar *FILENAME_GZ = _T("test.gz");
	4076	static const wxChar *TEST_DATA = _T("hello and hello and hello and hello and hello");
	4077
	4078	static void TestZlibStreamWrite()
	4079	{
	4080	wxPuts(_T("* Testing Zlib stream reading *\n"));
	4081
	4082	wxFileOutputStream fileOutStream(FILENAME_GZ);
	4083	wxZlibOutputStream ostr(fileOutStream);
	4084	wxPrintf(_T("Compressing the test string... "));
	4085	ostr.Write(TEST_DATA, wxStrlen(TEST_DATA) + 1);
	4086	if ( !ostr )
	4087	{
	4088	wxPuts(_T("(ERROR: failed)"));
	4089	}
	4090	else
	4091	{
	4092	wxPuts(_T("(ok)"));
	4093	}
	4094
	4095	wxPuts(_T("\n----- done ------"));
	4096	}
	4097
	4098	static void TestZlibStreamRead()
	4099	{
	4100	wxPuts(_T("* Testing Zlib stream reading *\n"));
	4101
	4102	wxFileInputStream fileInStream(FILENAME_GZ);
	4103	wxZlibInputStream istr(fileInStream);
	4104	wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
	4105
	4106	wxPuts(_T("Dumping the file:"));
	4107	while ( !istr.Eof() )
	4108	{
	4109	putchar(istr.GetC());
	4110	fflush(stdout);
	4111	}
	4112
	4113	wxPuts(_T("\n----- done ------"));
	4114	}
	4115
	4116	#endif // TEST_ZLIB
	4117
	4118	// ----------------------------------------------------------------------------
	4119	// date time
	4120	// ----------------------------------------------------------------------------
	4121
	4122	#ifdef TEST_DATETIME
	4123
	4124	#include <math.h>
	4125
	4126	#include "wx/date.h"
	4127	#include "wx/datetime.h"
	4128
	4129	// the test data
	4130	struct Date
	4131	{
	4132	wxDateTime::wxDateTime_t day;
	4133	wxDateTime::Month month;
	4134	int year;
	4135	wxDateTime::wxDateTime_t hour, min, sec;
	4136	double jdn;
	4137	wxDateTime::WeekDay wday;
	4138	time_t gmticks, ticks;
	4139
	4140	void Init(const wxDateTime::Tm& tm)
	4141	{
	4142	day = tm.mday;
	4143	month = tm.mon;
	4144	year = tm.year;
	4145	hour = tm.hour;
	4146	min = tm.min;
	4147	sec = tm.sec;
	4148	jdn = 0.0;
	4149	gmticks = ticks = -1;
	4150	}
	4151
	4152	wxDateTime DT() const
	4153	{ return wxDateTime(day, month, year, hour, min, sec); }
	4154
	4155	bool SameDay(const wxDateTime::Tm& tm) const
	4156	{
	4157	return day == tm.mday && month == tm.mon && year == tm.year;
	4158	}
	4159
	4160	wxString Format() const
	4161	{
	4162	wxString s;
	4163	s.Printf(_T("%02d:%02d:%02d %10s %02d, %4d%s"),
	4164	hour, min, sec,
	4165	wxDateTime::GetMonthName(month).c_str(),
	4166	day,
	4167	abs(wxDateTime::ConvertYearToBC(year)),
	4168	year > 0 ? _T("AD") : _T("BC"));
	4169	return s;
	4170	}
	4171
	4172	wxString FormatDate() const
	4173	{
	4174	wxString s;
	4175	s.Printf(_T("%02d-%s-%4d%s"),
	4176	day,
	4177	wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
	4178	abs(wxDateTime::ConvertYearToBC(year)),
	4179	year > 0 ? _T("AD") : _T("BC"));
	4180	return s;
	4181	}
	4182	};
	4183
	4184	static const Date testDates[] =
	4185	{
	4186	{ 1, wxDateTime::Jan, 1970, 00, 00, 00, 2440587.5, wxDateTime::Thu, 0, -3600 },
	4187	{ 7, wxDateTime::Feb, 2036, 00, 00, 00, 2464730.5, wxDateTime::Thu, -1, -1 },
	4188	{ 8, wxDateTime::Feb, 2036, 00, 00, 00, 2464731.5, wxDateTime::Fri, -1, -1 },
	4189	{ 1, wxDateTime::Jan, 2037, 00, 00, 00, 2465059.5, wxDateTime::Thu, -1, -1 },
	4190	{ 1, wxDateTime::Jan, 2038, 00, 00, 00, 2465424.5, wxDateTime::Fri, -1, -1 },
	4191	{ 21, wxDateTime::Jan, 2222, 00, 00, 00, 2532648.5, wxDateTime::Mon, -1, -1 },
	4192	{ 29, wxDateTime::May, 1976, 12, 00, 00, 2442928.0, wxDateTime::Sat, 202219200, 202212000 },
	4193	{ 29, wxDateTime::Feb, 1976, 00, 00, 00, 2442837.5, wxDateTime::Sun, 194400000, 194396400 },
	4194	{ 1, wxDateTime::Jan, 1900, 12, 00, 00, 2415021.0, wxDateTime::Mon, -1, -1 },
	4195	{ 1, wxDateTime::Jan, 1900, 00, 00, 00, 2415020.5, wxDateTime::Mon, -1, -1 },
	4196	{ 15, wxDateTime::Oct, 1582, 00, 00, 00, 2299160.5, wxDateTime::Fri, -1, -1 },
	4197	{ 4, wxDateTime::Oct, 1582, 00, 00, 00, 2299149.5, wxDateTime::Mon, -1, -1 },
	4198	{ 1, wxDateTime::Mar, 1, 00, 00, 00, 1721484.5, wxDateTime::Thu, -1, -1 },
	4199	{ 1, wxDateTime::Jan, 1, 00, 00, 00, 1721425.5, wxDateTime::Mon, -1, -1 },
	4200	{ 31, wxDateTime::Dec, 0, 00, 00, 00, 1721424.5, wxDateTime::Sun, -1, -1 },
	4201	{ 1, wxDateTime::Jan, 0, 00, 00, 00, 1721059.5, wxDateTime::Sat, -1, -1 },
	4202	{ 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, wxDateTime::Fri, -1, -1 },
	4203	{ 12, wxDateTime::Aug, -4000, 00, 00, 00, 260313.5, wxDateTime::Sat, -1, -1 },
	4204	{ 24, wxDateTime::Nov, -4713, 00, 00, 00, -0.5, wxDateTime::Mon, -1, -1 },
	4205	};
	4206
	4207	// this test miscellaneous static wxDateTime functions
	4208	static void TestTimeStatic()
	4209	{
	4210	wxPuts(_T("\n* wxDateTime static methods test *"));
	4211
	4212	// some info about the current date
	4213	int year = wxDateTime::GetCurrentYear();
	4214	wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
	4215	year,
	4216	wxDateTime::IsLeapYear(year) ? "" : "not ",
	4217	wxDateTime::GetNumberOfDays(year));
	4218
	4219	wxDateTime::Month month = wxDateTime::GetCurrentMonth();
	4220	wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
	4221	wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
	4222	wxDateTime::GetMonthName(month).c_str(),
	4223	wxDateTime::GetNumberOfDays(month));
	4224
	4225	// leap year logic
	4226	static const size_t nYears = 5;
	4227	static const size_t years[2][nYears] =
	4228	{
	4229	// first line: the years to test
	4230	{ 1990, 1976, 2000, 2030, 1984, },
	4231
	4232	// second line: TRUE if leap, FALSE otherwise
	4233	{ FALSE, TRUE, TRUE, FALSE, TRUE }
	4234	};
	4235
	4236	for ( size_t n = 0; n < nYears; n++ )
	4237	{
	4238	int year = years[0][n];
	4239	bool should = years[1][n] != 0,
	4240	is = wxDateTime::IsLeapYear(year);
	4241
	4242	wxPrintf(_T("Year %d is %sa leap year (%s)\n"),
	4243	year,
	4244	is ? "" : "not ",
	4245	should == is ? "ok" : "ERROR");
	4246
	4247	wxASSERT( should == wxDateTime::IsLeapYear(year) );
	4248	}
	4249	}
	4250
	4251	// test constructing wxDateTime objects
	4252	static void TestTimeSet()
	4253	{
	4254	wxPuts(_T("\n* wxDateTime construction test *"));
	4255
	4256	for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
	4257	{
	4258	const Date& d1 = testDates[n];
	4259	wxDateTime dt = d1.DT();
	4260
	4261	Date d2;
	4262	d2.Init(dt.GetTm());
	4263
	4264	wxString s1 = d1.Format(),
	4265	s2 = d2.Format();
	4266
	4267	wxPrintf(_T("Date: %s == %s (%s)\n"),
	4268	s1.c_str(), s2.c_str(),
	4269	s1 == s2 ? _T("ok") : _T("ERROR"));
	4270	}
	4271	}
	4272
	4273	// test time zones stuff
	4274	static void TestTimeZones()
	4275	{
	4276	wxPuts(_T("\n* wxDateTime timezone test *"));
	4277
	4278	wxDateTime now = wxDateTime::Now();
	4279
	4280	wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
	4281	wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
	4282	wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
	4283	wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
	4284	wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
	4285	wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
	4286
	4287	wxDateTime::Tm tm = now.GetTm();
	4288	if ( wxDateTime(tm) != now )
	4289	{
	4290	wxPrintf(_T("ERROR: got %s instead of %s\n"),
	4291	wxDateTime(tm).Format().c_str(), now.Format().c_str());
	4292	}
	4293	}
	4294
	4295	// test some minimal support for the dates outside the standard range
	4296	static void TestTimeRange()
	4297	{
	4298	wxPuts(_T("\n* wxDateTime out-of-standard-range dates test *"));
	4299
	4300	static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
	4301
	4302	wxPrintf(_T("Unix epoch:\t%s\n"),
	4303	wxDateTime(2440587.5).Format(fmt).c_str());
	4304	wxPrintf(_T("Feb 29, 0: \t%s\n"),
	4305	wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
	4306	wxPrintf(_T("JDN 0: \t%s\n"),
	4307	wxDateTime(0.0).Format(fmt).c_str());
	4308	wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
	4309	wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
	4310	wxPrintf(_T("May 29, 2099:\t%s\n"),
	4311	wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
	4312	}
	4313
	4314	static void TestTimeTicks()
	4315	{
	4316	wxPuts(_T("\n* wxDateTime ticks test *"));
	4317
	4318	for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
	4319	{
	4320	const Date& d = testDates[n];
	4321	if ( d.ticks == -1 )
	4322	continue;
	4323
	4324	wxDateTime dt = d.DT();
	4325	long ticks = (dt.GetValue() / 1000).ToLong();
	4326	wxPrintf(_T("Ticks of %s:\t% 10ld"), d.Format().c_str(), ticks);
	4327	if ( ticks == d.ticks )
	4328	{
	4329	wxPuts(_T(" (ok)"));
	4330	}
	4331	else
	4332	{
	4333	wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
	4334	(long)d.ticks, (long)(ticks - d.ticks));
	4335	}
	4336
	4337	dt = d.DT().ToTimezone(wxDateTime::GMT0);
	4338	ticks = (dt.GetValue() / 1000).ToLong();
	4339	wxPrintf(_T("GMtks of %s:\t% 10ld"), d.Format().c_str(), ticks);
	4340	if ( ticks == d.gmticks )
	4341	{
	4342	wxPuts(_T(" (ok)"));
	4343	}
	4344	else
	4345	{
	4346	wxPrintf(_T(" (ERROR: should be %ld, delta = %ld)\n"),
	4347	(long)d.gmticks, (long)(ticks - d.gmticks));
	4348	}
	4349	}
	4350
	4351	wxPuts(_T(""));
	4352	}
	4353
	4354	// test conversions to JDN &c
	4355	static void TestTimeJDN()
	4356	{
	4357	wxPuts(_T("\n* wxDateTime to JDN test *"));
	4358
	4359	for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
	4360	{
	4361	const Date& d = testDates[n];
	4362	wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
	4363	double jdn = dt.GetJulianDayNumber();
	4364
	4365	wxPrintf(_T("JDN of %s is:\t% 15.6f"), d.Format().c_str(), jdn);
	4366	if ( jdn == d.jdn )
	4367	{
	4368	wxPuts(_T(" (ok)"));
	4369	}
	4370	else
	4371	{
	4372	wxPrintf(_T(" (ERROR: should be %f, delta = %f)\n"),
	4373	d.jdn, jdn - d.jdn);
	4374	}
	4375	}
	4376	}
	4377
	4378	// test week days computation
	4379	static void TestTimeWDays()
	4380	{
	4381	wxPuts(_T("\n* wxDateTime weekday test *"));
	4382
	4383	// test GetWeekDay()
	4384	size_t n;
	4385	for ( n = 0; n < WXSIZEOF(testDates); n++ )
	4386	{
	4387	const Date& d = testDates[n];
	4388	wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec);
	4389
	4390	wxDateTime::WeekDay wday = dt.GetWeekDay();
	4391	wxPrintf(_T("%s is: %s"),
	4392	d.Format().c_str(),
	4393	wxDateTime::GetWeekDayName(wday).c_str());
	4394	if ( wday == d.wday )
	4395	{
	4396	wxPuts(_T(" (ok)"));
	4397	}
	4398	else
	4399	{
	4400	wxPrintf(_T(" (ERROR: should be %s)\n"),
	4401	wxDateTime::GetWeekDayName(d.wday).c_str());
	4402	}
	4403	}
	4404
	4405	wxPuts(_T(""));
	4406
	4407	// test SetToWeekDay()
	4408	struct WeekDateTestData
	4409	{
	4410	Date date; // the real date (precomputed)
	4411	int nWeek; // its week index in the month
	4412	wxDateTime::WeekDay wday; // the weekday
	4413	wxDateTime::Month month; // the month
	4414	int year; // and the year
	4415
	4416	wxString Format() const
	4417	{
	4418	wxString s, which;
	4419	switch ( nWeek < -1 ? -nWeek : nWeek )
	4420	{
	4421	case 1: which = _T("first"); break;
	4422	case 2: which = _T("second"); break;
	4423	case 3: which = _T("third"); break;
	4424	case 4: which = _T("fourth"); break;
	4425	case 5: which = _T("fifth"); break;
	4426
	4427	case -1: which = _T("last"); break;
	4428	}
	4429
	4430	if ( nWeek < -1 )
	4431	{
	4432	which += _T(" from end");
	4433	}
	4434
	4435	s.Printf(_T("The %s %s of %s in %d"),
	4436	which.c_str(),
	4437	wxDateTime::GetWeekDayName(wday).c_str(),
	4438	wxDateTime::GetMonthName(month).c_str(),
	4439	year);
	4440
	4441	return s;
	4442	}
	4443	};
	4444
	4445	// the array data was generated by the following python program
	4446	/*
	4447	from DateTime import *
	4448	from whrandom import *
	4449	from string import *
	4450
	4451	monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
	4452	wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
	4453
	4454	week = DateTimeDelta(7)
	4455
	4456	for n in range(20):
	4457	year = randint(1900, 2100)
	4458	month = randint(1, 12)
	4459	day = randint(1, 28)
	4460	dt = DateTime(year, month, day)
	4461	wday = dt.day_of_week
	4462
	4463	countFromEnd = choice([-1, 1])
	4464	weekNum = 0;
	4465
	4466	while dt.month is month:
	4467	dt = dt - countFromEnd * week
	4468	weekNum = weekNum + countFromEnd
	4469
	4470	data = { 'day': rjust(`day`, 2), 'month': monthNames[month - 1], 'year': year, 'weekNum': rjust(`weekNum`, 2), 'wday': wdayNames[wday] }
	4471
	4472	print "{ { %(day)s, wxDateTime::%(month)s, %(year)d }, %(weekNum)d, "\
	4473	"wxDateTime::%(wday)s, wxDateTime::%(month)s, %(year)d }," % data
	4474	*/
	4475
	4476	static const WeekDateTestData weekDatesTestData[] =
	4477	{
	4478	{ { 20, wxDateTime::Mar, 2045 }, 3, wxDateTime::Mon, wxDateTime::Mar, 2045 },
	4479	{ { 5, wxDateTime::Jun, 1985 }, -4, wxDateTime::Wed, wxDateTime::Jun, 1985 },
	4480	{ { 12, wxDateTime::Nov, 1961 }, -3, wxDateTime::Sun, wxDateTime::Nov, 1961 },
	4481	{ { 27, wxDateTime::Feb, 2093 }, -1, wxDateTime::Fri, wxDateTime::Feb, 2093 },
	4482	{ { 4, wxDateTime::Jul, 2070 }, -4, wxDateTime::Fri, wxDateTime::Jul, 2070 },
	4483	{ { 2, wxDateTime::Apr, 1906 }, -5, wxDateTime::Mon, wxDateTime::Apr, 1906 },
	4484	{ { 19, wxDateTime::Jul, 2023 }, -2, wxDateTime::Wed, wxDateTime::Jul, 2023 },
	4485	{ { 5, wxDateTime::May, 1958 }, -4, wxDateTime::Mon, wxDateTime::May, 1958 },
	4486	{ { 11, wxDateTime::Aug, 1900 }, 2, wxDateTime::Sat, wxDateTime::Aug, 1900 },
	4487	{ { 14, wxDateTime::Feb, 1945 }, 2, wxDateTime::Wed, wxDateTime::Feb, 1945 },
	4488	{ { 25, wxDateTime::Jul, 1967 }, -1, wxDateTime::Tue, wxDateTime::Jul, 1967 },
	4489	{ { 9, wxDateTime::May, 1916 }, -4, wxDateTime::Tue, wxDateTime::May, 1916 },
	4490	{ { 20, wxDateTime::Jun, 1927 }, 3, wxDateTime::Mon, wxDateTime::Jun, 1927 },
	4491	{ { 2, wxDateTime::Aug, 2000 }, 1, wxDateTime::Wed, wxDateTime::Aug, 2000 },
	4492	{ { 20, wxDateTime::Apr, 2044 }, 3, wxDateTime::Wed, wxDateTime::Apr, 2044 },
	4493	{ { 20, wxDateTime::Feb, 1932 }, -2, wxDateTime::Sat, wxDateTime::Feb, 1932 },
	4494	{ { 25, wxDateTime::Jul, 2069 }, 4, wxDateTime::Thu, wxDateTime::Jul, 2069 },
	4495	{ { 3, wxDateTime::Apr, 1925 }, 1, wxDateTime::Fri, wxDateTime::Apr, 1925 },
	4496	{ { 21, wxDateTime::Mar, 2093 }, 3, wxDateTime::Sat, wxDateTime::Mar, 2093 },
	4497	{ { 3, wxDateTime::Dec, 2074 }, -5, wxDateTime::Mon, wxDateTime::Dec, 2074 },
	4498	};
	4499
	4500	static const wxChar *fmt = _T("%d-%b-%Y");
	4501
	4502	wxDateTime dt;
	4503	for ( n = 0; n < WXSIZEOF(weekDatesTestData); n++ )
	4504	{
	4505	const WeekDateTestData& wd = weekDatesTestData[n];
	4506
	4507	dt.SetToWeekDay(wd.wday, wd.nWeek, wd.month, wd.year);
	4508
	4509	wxPrintf(_T("%s is %s"), wd.Format().c_str(), dt.Format(fmt).c_str());
	4510
	4511	const Date& d = wd.date;
	4512	if ( d.SameDay(dt.GetTm()) )
	4513	{
	4514	wxPuts(_T(" (ok)"));
	4515	}
	4516	else
	4517	{
	4518	dt.Set(d.day, d.month, d.year);
	4519
	4520	wxPrintf(_T(" (ERROR: should be %s)\n"), dt.Format(fmt).c_str());
	4521	}
	4522	}
	4523	}
	4524
	4525	// test the computation of (ISO) week numbers
	4526	static void TestTimeWNumber()
	4527	{
	4528	wxPuts(_T("\n* wxDateTime week number test *"));
	4529
	4530	struct WeekNumberTestData
	4531	{
	4532	Date date; // the date
	4533	wxDateTime::wxDateTime_t week; // the week number in the year
	4534	wxDateTime::wxDateTime_t wmon; // the week number in the month
	4535	wxDateTime::wxDateTime_t wmon2; // same but week starts with Sun
	4536	wxDateTime::wxDateTime_t dnum; // day number in the year
	4537	};
	4538
	4539	// data generated with the following python script:
	4540	/*
	4541	from DateTime import *
	4542	from whrandom import *
	4543	from string import *
	4544
	4545	monthNames = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
	4546	wdayNames = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ]
	4547
	4548	def GetMonthWeek(dt):
	4549	weekNumMonth = dt.iso_week[1] - DateTime(dt.year, dt.month, 1).iso_week[1] + 1
	4550	if weekNumMonth < 0:
	4551	weekNumMonth = weekNumMonth + 53
	4552	return weekNumMonth
	4553
	4554	def GetLastSundayBefore(dt):
	4555	if dt.iso_week[2] == 7:
	4556	return dt
	4557	else:
	4558	return dt - DateTimeDelta(dt.iso_week[2])
	4559
	4560	for n in range(20):
	4561	year = randint(1900, 2100)
	4562	month = randint(1, 12)
	4563	day = randint(1, 28)
	4564	dt = DateTime(year, month, day)
	4565	dayNum = dt.day_of_year
	4566	weekNum = dt.iso_week[1]
	4567	weekNumMonth = GetMonthWeek(dt)
	4568
	4569	weekNumMonth2 = 0
	4570	dtSunday = GetLastSundayBefore(dt)
	4571
	4572	while dtSunday >= GetLastSundayBefore(DateTime(dt.year, dt.month, 1)):
	4573	weekNumMonth2 = weekNumMonth2 + 1
	4574	dtSunday = dtSunday - DateTimeDelta(7)
	4575
	4576	data = { 'day': rjust(`day`, 2), \
	4577	'month': monthNames[month - 1], \
	4578	'year': year, \
	4579	'weekNum': rjust(`weekNum`, 2), \
	4580	'weekNumMonth': weekNumMonth, \
	4581	'weekNumMonth2': weekNumMonth2, \
	4582	'dayNum': rjust(`dayNum`, 3) }
	4583
	4584	print " { { %(day)s, "\
	4585	"wxDateTime::%(month)s, "\
	4586	"%(year)d }, "\
	4587	"%(weekNum)s, "\
	4588	"%(weekNumMonth)s, "\
	4589	"%(weekNumMonth2)s, "\
	4590	"%(dayNum)s }," % data
	4591
	4592	*/
	4593	static const WeekNumberTestData weekNumberTestDates[] =
	4594	{
	4595	{ { 27, wxDateTime::Dec, 1966 }, 52, 5, 5, 361 },
	4596	{ { 22, wxDateTime::Jul, 1926 }, 29, 4, 4, 203 },
	4597	{ { 22, wxDateTime::Oct, 2076 }, 43, 4, 4, 296 },
	4598	{ { 1, wxDateTime::Jul, 1967 }, 26, 1, 1, 182 },
	4599	{ { 8, wxDateTime::Nov, 2004 }, 46, 2, 2, 313 },
	4600	{ { 21, wxDateTime::Mar, 1920 }, 12, 3, 4, 81 },
	4601	{ { 7, wxDateTime::Jan, 1965 }, 1, 2, 2, 7 },
	4602	{ { 19, wxDateTime::Oct, 1999 }, 42, 4, 4, 292 },
	4603	{ { 13, wxDateTime::Aug, 1955 }, 32, 2, 2, 225 },
	4604	{ { 18, wxDateTime::Jul, 2087 }, 29, 3, 3, 199 },
	4605	{ { 2, wxDateTime::Sep, 2028 }, 35, 1, 1, 246 },
	4606	{ { 28, wxDateTime::Jul, 1945 }, 30, 5, 4, 209 },
	4607	{ { 15, wxDateTime::Jun, 1901 }, 24, 3, 3, 166 },
	4608	{ { 10, wxDateTime::Oct, 1939 }, 41, 3, 2, 283 },
	4609	{ { 3, wxDateTime::Dec, 1965 }, 48, 1, 1, 337 },
	4610	{ { 23, wxDateTime::Feb, 1940 }, 8, 4, 4, 54 },
	4611	{ { 2, wxDateTime::Jan, 1987 }, 1, 1, 1, 2 },
	4612	{ { 11, wxDateTime::Aug, 2079 }, 32, 2, 2, 223 },
	4613	{ { 2, wxDateTime::Feb, 2063 }, 5, 1, 1, 33 },
	4614	{ { 16, wxDateTime::Oct, 1942 }, 42, 3, 3, 289 },
	4615	};
	4616
	4617	for ( size_t n = 0; n < WXSIZEOF(weekNumberTestDates); n++ )
	4618	{
	4619	const WeekNumberTestData& wn = weekNumberTestDates[n];
	4620	const Date& d = wn.date;
	4621
	4622	wxDateTime dt = d.DT();
	4623
	4624	wxDateTime::wxDateTime_t
	4625	week = dt.GetWeekOfYear(wxDateTime::Monday_First),
	4626	wmon = dt.GetWeekOfMonth(wxDateTime::Monday_First),
	4627	wmon2 = dt.GetWeekOfMonth(wxDateTime::Sunday_First),
	4628	dnum = dt.GetDayOfYear();
	4629
	4630	wxPrintf(_T("%s: the day number is %d"), d.FormatDate().c_str(), dnum);
	4631	if ( dnum == wn.dnum )
	4632	{
	4633	wxPrintf(_T(" (ok)"));
	4634	}
	4635	else
	4636	{
	4637	wxPrintf(_T(" (ERROR: should be %d)"), wn.dnum);
	4638	}
	4639
	4640	wxPrintf(_T(", week in month = %d"), wmon);
	4641	if ( wmon != wn.wmon )
	4642	{
	4643	wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon);
	4644	}
	4645
	4646	wxPrintf(_T(" or %d"), wmon2);
	4647	if ( wmon2 == wn.wmon2 )
	4648	{
	4649	wxPrintf(_T(" (ok)"));
	4650	}
	4651	else
	4652	{
	4653	wxPrintf(_T(" (ERROR: should be %d)"), wn.wmon2);
	4654	}
	4655
	4656	wxPrintf(_T(", week in year = %d"), week);
	4657	if ( week != wn.week )
	4658	{
	4659	wxPrintf(_T(" (ERROR: should be %d)"), wn.week);
	4660	}
	4661
	4662	wxPutchar(_T('\n'));
	4663
	4664	wxDateTime dt2(1, wxDateTime::Jan, d.year);
	4665	dt2.SetToTheWeek(wn.week, dt.GetWeekDay());
	4666	if ( dt2 != dt )
	4667	{
	4668	Date d2;
	4669	d2.Init(dt2.GetTm());
	4670	wxPrintf(_T("ERROR: SetToTheWeek() returned %s\n"),
	4671	d2.FormatDate().c_str());
	4672	}
	4673	}
	4674	}
	4675
	4676	// test DST calculations
	4677	static void TestTimeDST()
	4678	{
	4679	wxPuts(_T("\n* wxDateTime DST test *"));
	4680
	4681	wxPrintf(_T("DST is%s in effect now.\n\n"),
	4682	wxDateTime::Now().IsDST() ? _T("") : _T(" not"));
	4683
	4684	// taken from http://www.energy.ca.gov/daylightsaving.html
	4685	static const Date datesDST[2][2004 - 1900 + 1] =
	4686	{
	4687	{
	4688	{ 1, wxDateTime::Apr, 1990 },
	4689	{ 7, wxDateTime::Apr, 1991 },
	4690	{ 5, wxDateTime::Apr, 1992 },
	4691	{ 4, wxDateTime::Apr, 1993 },
	4692	{ 3, wxDateTime::Apr, 1994 },
	4693	{ 2, wxDateTime::Apr, 1995 },
	4694	{ 7, wxDateTime::Apr, 1996 },
	4695	{ 6, wxDateTime::Apr, 1997 },
	4696	{ 5, wxDateTime::Apr, 1998 },
	4697	{ 4, wxDateTime::Apr, 1999 },
	4698	{ 2, wxDateTime::Apr, 2000 },
	4699	{ 1, wxDateTime::Apr, 2001 },
	4700	{ 7, wxDateTime::Apr, 2002 },
	4701	{ 6, wxDateTime::Apr, 2003 },
	4702	{ 4, wxDateTime::Apr, 2004 },
	4703	},
	4704	{
	4705	{ 28, wxDateTime::Oct, 1990 },
	4706	{ 27, wxDateTime::Oct, 1991 },
	4707	{ 25, wxDateTime::Oct, 1992 },
	4708	{ 31, wxDateTime::Oct, 1993 },
	4709	{ 30, wxDateTime::Oct, 1994 },
	4710	{ 29, wxDateTime::Oct, 1995 },
	4711	{ 27, wxDateTime::Oct, 1996 },
	4712	{ 26, wxDateTime::Oct, 1997 },
	4713	{ 25, wxDateTime::Oct, 1998 },
	4714	{ 31, wxDateTime::Oct, 1999 },
	4715	{ 29, wxDateTime::Oct, 2000 },
	4716	{ 28, wxDateTime::Oct, 2001 },
	4717	{ 27, wxDateTime::Oct, 2002 },
	4718	{ 26, wxDateTime::Oct, 2003 },
	4719	{ 31, wxDateTime::Oct, 2004 },
	4720	}
	4721	};
	4722
	4723	int year;
	4724	for ( year = 1990; year < 2005; year++ )
	4725	{
	4726	wxDateTime dtBegin = wxDateTime::GetBeginDST(year, wxDateTime::USA),
	4727	dtEnd = wxDateTime::GetEndDST(year, wxDateTime::USA);
	4728
	4729	wxPrintf(_T("DST period in the US for year %d: from %s to %s"),
	4730	year, dtBegin.Format().c_str(), dtEnd.Format().c_str());
	4731
	4732	size_t n = year - 1990;
	4733	const Date& dBegin = datesDST[0][n];
	4734	const Date& dEnd = datesDST[1][n];
	4735
	4736	if ( dBegin.SameDay(dtBegin.GetTm()) && dEnd.SameDay(dtEnd.GetTm()) )
	4737	{
	4738	wxPuts(_T(" (ok)"));
	4739	}
	4740	else
	4741	{
	4742	wxPrintf(_T(" (ERROR: should be %s %d to %s %d)\n"),
	4743	wxDateTime::GetMonthName(dBegin.month).c_str(), dBegin.day,
	4744	wxDateTime::GetMonthName(dEnd.month).c_str(), dEnd.day);
	4745	}
	4746	}
	4747
	4748	wxPuts(_T(""));
	4749
	4750	for ( year = 1990; year < 2005; year++ )
	4751	{
	4752	wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
	4753	year,
	4754	wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
	4755	wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
	4756	}
	4757	}
	4758
	4759	// test wxDateTime -> text conversion
	4760	static void TestTimeFormat()
	4761	{
	4762	wxPuts(_T("\n* wxDateTime formatting test *"));
	4763
	4764	// some information may be lost during conversion, so store what kind
	4765	// of info should we recover after a round trip
	4766	enum CompareKind
	4767	{
	4768	CompareNone, // don't try comparing
	4769	CompareBoth, // dates and times should be identical
	4770	CompareDate, // dates only
	4771	CompareTime // time only
	4772	};
	4773
	4774	static const struct
	4775	{
	4776	CompareKind compareKind;
	4777	const wxChar *format;
	4778	} formatTestFormats[] =
	4779	{
	4780	{ CompareBoth, _T("---> %c") },
	4781	{ CompareDate, _T("Date is %A, %d of %B, in year %Y") },
	4782	{ CompareBoth, _T("Date is %x, time is %X") },
	4783	{ CompareTime, _T("Time is %H:%M:%S or %I:%M:%S %p") },
	4784	{ CompareNone, _T("The day of year: %j, the week of year: %W") },
	4785	{ CompareDate, _T("ISO date without separators: %Y%m%d") },
	4786	};
	4787
	4788	static const Date formatTestDates[] =
	4789	{
	4790	{ 29, wxDateTime::May, 1976, 18, 30, 00 },
	4791	{ 31, wxDateTime::Dec, 1999, 23, 30, 00 },
	4792	#if 0
	4793	// this test can't work for other centuries because it uses two digit
	4794	// years in formats, so don't even try it
	4795	{ 29, wxDateTime::May, 2076, 18, 30, 00 },
	4796	{ 29, wxDateTime::Feb, 2400, 02, 15, 25 },
	4797	{ 01, wxDateTime::Jan, -52, 03, 16, 47 },
	4798	#endif
	4799	};
	4800
	4801	// an extra test (as it doesn't depend on date, don't do it in the loop)
	4802	wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
	4803
	4804	for ( size_t d = 0; d < WXSIZEOF(formatTestDates) + 1; d++ )
	4805	{
	4806	wxPuts(_T(""));
	4807
	4808	wxDateTime dt = d == 0 ? wxDateTime::Now() : formatTestDates[d - 1].DT();
	4809	for ( size_t n = 0; n < WXSIZEOF(formatTestFormats); n++ )
	4810	{
	4811	wxString s = dt.Format(formatTestFormats[n].format);
	4812	wxPrintf(_T("%s"), s.c_str());
	4813
	4814	// what can we recover?
	4815	int kind = formatTestFormats[n].compareKind;
	4816
	4817	// convert back
	4818	wxDateTime dt2;
	4819	const wxChar *result = dt2.ParseFormat(s, formatTestFormats[n].format);
	4820	if ( !result )
	4821	{
	4822	// converion failed - should it have?
	4823	if ( kind == CompareNone )
	4824	wxPuts(_T(" (ok)"));
	4825	else
	4826	wxPuts(_T(" (ERROR: conversion back failed)"));
	4827	}
	4828	else if ( *result )
	4829	{
	4830	// should have parsed the entire string
	4831	wxPuts(_T(" (ERROR: conversion back stopped too soon)"));
	4832	}
	4833	else
	4834	{
	4835	bool equal = FALSE; // suppress compilaer warning
	4836	switch ( kind )
	4837	{
	4838	case CompareBoth:
	4839	equal = dt2 == dt;
	4840	break;
	4841
	4842	case CompareDate:
	4843	equal = dt.IsSameDate(dt2);
	4844	break;
	4845
	4846	case CompareTime:
	4847	equal = dt.IsSameTime(dt2);
	4848	break;
	4849	}
	4850
	4851	if ( !equal )
	4852	{
	4853	wxPrintf(_T(" (ERROR: got back '%s' instead of '%s')\n"),
	4854	dt2.Format().c_str(), dt.Format().c_str());
	4855	}
	4856	else
	4857	{
	4858	wxPuts(_T(" (ok)"));
	4859	}
	4860	}
	4861	}
	4862	}
	4863	}
	4864
	4865	// test text -> wxDateTime conversion
	4866	static void TestTimeParse()
	4867	{
	4868	wxPuts(_T("\n* wxDateTime parse test *"));
	4869
	4870	struct ParseTestData
	4871	{
	4872	const wxChar *format;
	4873	Date date;
	4874	bool good;
	4875	};
	4876
	4877	static const ParseTestData parseTestDates[] =
	4878	{
	4879	{ _T("Sat, 18 Dec 1999 00:46:40 +0100"), { 18, wxDateTime::Dec, 1999, 00, 46, 40 }, TRUE },
	4880	{ _T("Wed, 1 Dec 1999 05:17:20 +0300"), { 1, wxDateTime::Dec, 1999, 03, 17, 20 }, TRUE },
	4881	};
	4882
	4883	for ( size_t n = 0; n < WXSIZEOF(parseTestDates); n++ )
	4884	{
	4885	const wxChar *format = parseTestDates[n].format;
	4886
	4887	wxPrintf(_T("%s => "), format);
	4888
	4889	wxDateTime dt;
	4890	if ( dt.ParseRfc822Date(format) )
	4891	{
	4892	wxPrintf(_T("%s "), dt.Format().c_str());
	4893
	4894	if ( parseTestDates[n].good )
	4895	{
	4896	wxDateTime dtReal = parseTestDates[n].date.DT();
	4897	if ( dt == dtReal )
	4898	{
	4899	wxPuts(_T("(ok)"));
	4900	}
	4901	else
	4902	{
	4903	wxPrintf(_T("(ERROR: should be %s)\n"), dtReal.Format().c_str());
	4904	}
	4905	}
	4906	else
	4907	{
	4908	wxPuts(_T("(ERROR: bad format)"));
	4909	}
	4910	}
	4911	else
	4912	{
	4913	wxPrintf(_T("bad format (%s)\n"),
	4914	parseTestDates[n].good ? "ERROR" : "ok");
	4915	}
	4916	}
	4917	}
	4918
	4919	static void TestDateTimeInteractive()
	4920	{
	4921	wxPuts(_T("\n* interactive wxDateTime tests *"));
	4922
	4923	wxChar buf[128];
	4924
	4925	for ( ;; )
	4926	{
	4927	wxPrintf(_T("Enter a date: "));
	4928	if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
	4929	break;
	4930
	4931	// kill the last '\n'
	4932	buf[wxStrlen(buf) - 1] = 0;
	4933
	4934	wxDateTime dt;
	4935	const wxChar *p = dt.ParseDate(buf);
	4936	if ( !p )
	4937	{
	4938	wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
	4939
	4940	continue;
	4941	}
	4942	else if ( *p )
	4943	{
	4944	wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
	4945	}
	4946
	4947	wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
	4948	dt.Format(_T("%b %d, %Y")).c_str(),
	4949	dt.GetDayOfYear(),
	4950	dt.GetWeekOfMonth(wxDateTime::Monday_First),
	4951	dt.GetWeekOfMonth(wxDateTime::Sunday_First),
	4952	dt.GetWeekOfYear(wxDateTime::Monday_First));
	4953	}
	4954
	4955	wxPuts(_T("\n* done *"));
	4956	}
	4957
	4958	static void TestTimeMS()
	4959	{
	4960	wxPuts(_T("* testing millisecond-resolution support in wxDateTime *"));
	4961
	4962	wxDateTime dt1 = wxDateTime::Now(),
	4963	dt2 = wxDateTime::UNow();
	4964
	4965	wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
	4966	wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
	4967	wxPrintf(_T("Dummy loop: "));
	4968	for ( int i = 0; i < 6000; i++ )
	4969	{
	4970	//for ( int j = 0; j < 10; j++ )
	4971	{
	4972	wxString s;
	4973	s.Printf(_T("%g"), sqrt(i));
	4974	}
	4975
	4976	if ( !(i % 100) )
	4977	putchar('.');
	4978	}
	4979	wxPuts(_T(", done"));
	4980
	4981	dt1 = dt2;
	4982	dt2 = wxDateTime::UNow();
	4983	wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
	4984
	4985	wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
	4986
	4987	wxPuts(_T("\n* done *"));
	4988	}
	4989
	4990	static void TestTimeArithmetics()
	4991	{
	4992	wxPuts(_T("\n* testing arithmetic operations on wxDateTime *"));
	4993
	4994	static const struct ArithmData
	4995	{
	4996	ArithmData(const wxDateSpan& sp, const wxChar *nam)
	4997	: span(sp), name(nam) { }
	4998
	4999	wxDateSpan span;
	5000	const wxChar *name;
	5001	} testArithmData[] =
	5002	{
	5003	ArithmData(wxDateSpan::Day(), _T("day")),
	5004	ArithmData(wxDateSpan::Week(), _T("week")),
	5005	ArithmData(wxDateSpan::Month(), _T("month")),
	5006	ArithmData(wxDateSpan::Year(), _T("year")),
	5007	ArithmData(wxDateSpan(1, 2, 3, 4), _T("year, 2 months, 3 weeks, 4 days")),
	5008	};
	5009
	5010	wxDateTime dt(29, wxDateTime::Dec, 1999), dt1, dt2;
	5011
	5012	for ( size_t n = 0; n < WXSIZEOF(testArithmData); n++ )
	5013	{
	5014	wxDateSpan span = testArithmData[n].span;
	5015	dt1 = dt + span;
	5016	dt2 = dt - span;
	5017
	5018	const wxChar *name = testArithmData[n].name;
	5019	wxPrintf(_T("%s + %s = %s, %s - %s = %s\n"),
	5020	dt.FormatISODate().c_str(), name, dt1.FormatISODate().c_str(),
	5021	dt.FormatISODate().c_str(), name, dt2.FormatISODate().c_str());
	5022
	5023	wxPrintf(_T("Going back: %s"), (dt1 - span).FormatISODate().c_str());
	5024	if ( dt1 - span == dt )
	5025	{
	5026	wxPuts(_T(" (ok)"));
	5027	}
	5028	else
	5029	{
	5030	wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
	5031	}
	5032
	5033	wxPrintf(_T("Going forward: %s"), (dt2 + span).FormatISODate().c_str());
	5034	if ( dt2 + span == dt )
	5035	{
	5036	wxPuts(_T(" (ok)"));
	5037	}
	5038	else
	5039	{
	5040	wxPrintf(_T(" (ERROR: should be %s)\n"), dt.FormatISODate().c_str());
	5041	}
	5042
	5043	wxPrintf(_T("Double increment: %s"), (dt2 + 2*span).FormatISODate().c_str());
	5044	if ( dt2 + 2*span == dt1 )
	5045	{
	5046	wxPuts(_T(" (ok)"));
	5047	}
	5048	else
	5049	{
	5050	wxPrintf(_T(" (ERROR: should be %s)\n"), dt2.FormatISODate().c_str());
	5051	}
	5052
	5053	wxPuts(_T(""));
	5054	}
	5055	}
	5056
	5057	static void TestTimeHolidays()
	5058	{
	5059	wxPuts(_T("\n* testing wxDateTimeHolidayAuthority *\n"));
	5060
	5061	wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
	5062	wxDateTime dtStart(1, tm.mon, tm.year),
	5063	dtEnd = dtStart.GetLastMonthDay();
	5064
	5065	wxDateTimeArray hol;
	5066	wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
	5067
	5068	const wxChar *format = _T("%d-%b-%Y (%a)");
	5069
	5070	wxPrintf(_T("All holidays between %s and %s:\n"),
	5071	dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
	5072
	5073	size_t count = hol.GetCount();
	5074	for ( size_t n = 0; n < count; n++ )
	5075	{
	5076	wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
	5077	}
	5078
	5079	wxPuts(_T(""));
	5080	}
	5081
	5082	static void TestTimeZoneBug()
	5083	{
	5084	wxPuts(_T("\n* testing for DST/timezone bug *\n"));
	5085
	5086	wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
	5087	for ( int i = 0; i < 31; i++ )
	5088	{
	5089	wxPrintf(_T("Date %s: week day %s.\n"),
	5090	date.Format(_T("%d-%m-%Y")).c_str(),
	5091	date.GetWeekDayName(date.GetWeekDay()).c_str());
	5092
	5093	date += wxDateSpan::Day();
	5094	}
	5095
	5096	wxPuts(_T(""));
	5097	}
	5098
	5099	static void TestTimeSpanFormat()
	5100	{
	5101	wxPuts(_T("\n* wxTimeSpan tests *"));
	5102
	5103	static const wxChar *formats[] =
	5104	{
	5105	_T("(default) %H:%M:%S"),
	5106	_T("%E weeks and %D days"),
	5107	_T("%l milliseconds"),
	5108	_T("(with ms) %H:%M:%S:%l"),
	5109	_T("100%% of minutes is %M"), // test "%%"
	5110	_T("%D days and %H hours"),
	5111	_T("or also %S seconds"),
	5112	};
	5113
	5114	wxTimeSpan ts1(1, 2, 3, 4),
	5115	ts2(111, 222, 333);
	5116	for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
	5117	{
	5118	wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
	5119	ts1.Format(formats[n]).c_str(),
	5120	ts2.Format(formats[n]).c_str());
	5121	}
	5122
	5123	wxPuts(_T(""));
	5124	}
	5125
	5126	#if 0
	5127
	5128	// test compatibility with the old wxDate/wxTime classes
	5129	static void TestTimeCompatibility()
	5130	{
	5131	wxPuts(_T("\n* wxDateTime compatibility test *"));
	5132
	5133	wxPrintf(_T("wxDate for JDN 0: %s\n"), wxDate(0l).FormatDate().c_str());
	5134	wxPrintf(_T("wxDate for MJD 0: %s\n"), wxDate(2400000).FormatDate().c_str());
	5135
	5136	double jdnNow = wxDateTime::Now().GetJDN();
	5137	long jdnMidnight = (long)(jdnNow - 0.5);
	5138	wxPrintf(_T("wxDate for today: %s\n"), wxDate(jdnMidnight).FormatDate().c_str());
	5139
	5140	jdnMidnight = wxDate().Set().GetJulianDate();
	5141	wxPrintf(_T("wxDateTime for today: %s\n"),
	5142	wxDateTime((double)(jdnMidnight + 0.5)).Format("%c", wxDateTime::GMT0).c_str());
	5143
	5144	int flags = wxEUROPEAN;//wxFULL;
	5145	wxDate date;
	5146	date.Set();
	5147	wxPrintf(_T("Today is %s\n"), date.FormatDate(flags).c_str());
	5148	for ( int n = 0; n < 7; n++ )
	5149	{
	5150	wxPrintf(_T("Previous %s is %s\n"),
	5151	wxDateTime::GetWeekDayName((wxDateTime::WeekDay)n),
	5152	date.Previous(n + 1).FormatDate(flags).c_str());
	5153	}
	5154	}
	5155
	5156	#endif // 0
	5157
	5158	#endif // TEST_DATETIME
	5159
	5160	// ----------------------------------------------------------------------------
	5161	// wxTextInput/OutputStream
	5162	// ----------------------------------------------------------------------------
	5163
	5164	#ifdef TEST_TEXTSTREAM
	5165
	5166	#include "wx/txtstrm.h"
	5167	#include "wx/wfstream.h"
	5168
	5169	static void TestTextInputStream()
	5170	{
	5171	wxPuts(_T("\n* wxTextInputStream test *"));
	5172
	5173	wxFileInputStream fsIn(_T("testdata.fc"));
	5174	if ( !fsIn.Ok() )
	5175	{
	5176	wxPuts(_T("ERROR: couldn't open file."));
	5177	}
	5178	else
	5179	{
	5180	wxTextInputStream tis(fsIn);
	5181
	5182	size_t line = 1;
	5183	for ( ;; )
	5184	{
	5185	const wxString s = tis.ReadLine();
	5186
	5187	// line could be non empty if the last line of the file isn't
	5188	// terminated with EOL
	5189	if ( fsIn.Eof() && s.empty() )
	5190	break;
	5191
	5192	wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
	5193	}
	5194	}
	5195	}
	5196
	5197	#endif // TEST_TEXTSTREAM
	5198
	5199	// ----------------------------------------------------------------------------
	5200	// threads
	5201	// ----------------------------------------------------------------------------
	5202
	5203	#ifdef TEST_THREADS
	5204
	5205	#include "wx/thread.h"
	5206
	5207	static size_t gs_counter = (size_t)-1;
	5208	static wxCriticalSection gs_critsect;
	5209	static wxSemaphore gs_cond;
	5210
	5211	class MyJoinableThread : public wxThread
	5212	{
	5213	public:
	5214	MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
	5215	{ m_n = n; Create(); }
	5216
	5217	// thread execution starts here
	5218	virtual ExitCode Entry();
	5219
	5220	private:
	5221	size_t m_n;
	5222	};
	5223
	5224	wxThread::ExitCode MyJoinableThread::Entry()
	5225	{
	5226	unsigned long res = 1;
	5227	for ( size_t n = 1; n < m_n; n++ )
	5228	{
	5229	res *= n;
	5230
	5231	// it's a loooong calculation :-)
	5232	Sleep(100);
	5233	}
	5234
	5235	return (ExitCode)res;
	5236	}
	5237
	5238	class MyDetachedThread : public wxThread
	5239	{
	5240	public:
	5241	MyDetachedThread(size_t n, wxChar ch)
	5242	{
	5243	m_n = n;
	5244	m_ch = ch;
	5245	m_cancelled = FALSE;
	5246
	5247	Create();
	5248	}
	5249
	5250	// thread execution starts here
	5251	virtual ExitCode Entry();
	5252
	5253	// and stops here
	5254	virtual void OnExit();
	5255
	5256	private:
	5257	size_t m_n; // number of characters to write
	5258	wxChar m_ch; // character to write
	5259
	5260	bool m_cancelled; // FALSE if we exit normally
	5261	};
	5262
	5263	wxThread::ExitCode MyDetachedThread::Entry()
	5264	{
	5265	{
	5266	wxCriticalSectionLocker lock(gs_critsect);
	5267	if ( gs_counter == (size_t)-1 )
	5268	gs_counter = 1;
	5269	else
	5270	gs_counter++;
	5271	}
	5272
	5273	for ( size_t n = 0; n < m_n; n++ )
	5274	{
	5275	if ( TestDestroy() )
	5276	{
	5277	m_cancelled = TRUE;
	5278
	5279	break;
	5280	}
	5281
	5282	putchar(m_ch);
	5283	fflush(stdout);
	5284
	5285	wxThread::Sleep(100);
	5286	}
	5287
	5288	return 0;
	5289	}
	5290
	5291	void MyDetachedThread::OnExit()
	5292	{
	5293	wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
	5294
	5295	wxCriticalSectionLocker lock(gs_critsect);
	5296	if ( !--gs_counter && !m_cancelled )
	5297	gs_cond.Post();
	5298	}
	5299
	5300	static void TestDetachedThreads()
	5301	{
	5302	wxPuts(_T("\n* Testing detached threads *"));
	5303
	5304	static const size_t nThreads = 3;
	5305	MyDetachedThread *threads[nThreads];
	5306	size_t n;
	5307	for ( n = 0; n < nThreads; n++ )
	5308	{
	5309	threads[n] = new MyDetachedThread(10, 'A' + n);
	5310	}
	5311
	5312	threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
	5313	threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
	5314
	5315	for ( n = 0; n < nThreads; n++ )
	5316	{
	5317	threads[n]->Run();
	5318	}
	5319
	5320	// wait until all threads terminate
	5321	gs_cond.Wait();
	5322
	5323	wxPuts(_T(""));
	5324	}
	5325
	5326	static void TestJoinableThreads()
	5327	{
	5328	wxPuts(_T("\n* Testing a joinable thread (a loooong calculation...) *"));
	5329
	5330	// calc 10! in the background
	5331	MyJoinableThread thread(10);
	5332	thread.Run();
	5333
	5334	wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
	5335	(unsigned long)thread.Wait());
	5336	}
	5337
	5338	static void TestThreadSuspend()
	5339	{
	5340	wxPuts(_T("\n* Testing thread suspend/resume functions *"));
	5341
	5342	MyDetachedThread *thread = new MyDetachedThread(15, 'X');
	5343
	5344	thread->Run();
	5345
	5346	// this is for this demo only, in a real life program we'd use another
	5347	// condition variable which would be signaled from wxThread::Entry() to
	5348	// tell us that the thread really started running - but here just wait a
	5349	// bit and hope that it will be enough (the problem is, of course, that
	5350	// the thread might still not run when we call Pause() which will result
	5351	// in an error)
	5352	wxThread::Sleep(300);
	5353
	5354	for ( size_t n = 0; n < 3; n++ )
	5355	{
	5356	thread->Pause();
	5357
	5358	wxPuts(_T("\nThread suspended"));
	5359	if ( n > 0 )
	5360	{
	5361	// don't sleep but resume immediately the first time
	5362	wxThread::Sleep(300);
	5363	}
	5364	wxPuts(_T("Going to resume the thread"));
	5365
	5366	thread->Resume();
	5367	}
	5368
	5369	wxPuts(_T("Waiting until it terminates now"));
	5370
	5371	// wait until the thread terminates
	5372	gs_cond.Wait();
	5373
	5374	wxPuts(_T(""));
	5375	}
	5376
	5377	static void TestThreadDelete()
	5378	{
	5379	// As above, using Sleep() is only for testing here - we must use some
	5380	// synchronisation object instead to ensure that the thread is still
	5381	// running when we delete it - deleting a detached thread which already
	5382	// terminated will lead to a crash!
	5383
	5384	wxPuts(_T("\n* Testing thread delete function *"));
	5385
	5386	MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
	5387
	5388	thread0->Delete();
	5389
	5390	wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
	5391
	5392	MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
	5393
	5394	thread1->Run();
	5395
	5396	wxThread::Sleep(300);
	5397
	5398	thread1->Delete();
	5399
	5400	wxPuts(_T("\nDeleted a running thread."));
	5401
	5402	MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
	5403
	5404	thread2->Run();
	5405
	5406	wxThread::Sleep(300);
	5407
	5408	thread2->Pause();
	5409
	5410	thread2->Delete();
	5411
	5412	wxPuts(_T("\nDeleted a sleeping thread."));
	5413
	5414	MyJoinableThread thread3(20);
	5415	thread3.Run();
	5416
	5417	thread3.Delete();
	5418
	5419	wxPuts(_T("\nDeleted a joinable thread."));
	5420
	5421	MyJoinableThread thread4(2);
	5422	thread4.Run();
	5423
	5424	wxThread::Sleep(300);
	5425
	5426	thread4.Delete();
	5427
	5428	wxPuts(_T("\nDeleted a joinable thread which already terminated."));
	5429
	5430	wxPuts(_T(""));
	5431	}
	5432
	5433	class MyWaitingThread : public wxThread
	5434	{
	5435	public:
	5436	MyWaitingThread( wxMutex mutex, wxCondition condition )
	5437	{
	5438	m_mutex = mutex;
	5439	m_condition = condition;
	5440
	5441	Create();
	5442	}
	5443
	5444	virtual ExitCode Entry()
	5445	{
	5446	wxPrintf(_T("Thread %lu has started running.\n"), GetId());
	5447	fflush(stdout);
	5448
	5449	gs_cond.Post();
	5450
	5451	wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
	5452	fflush(stdout);
	5453
	5454	m_mutex->Lock();
	5455	m_condition->Wait();
	5456	m_mutex->Unlock();
	5457
	5458	wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
	5459	fflush(stdout);
	5460
	5461	return 0;
	5462	}
	5463
	5464	private:
	5465	wxMutex *m_mutex;
	5466	wxCondition *m_condition;
	5467	};
	5468
	5469	static void TestThreadConditions()
	5470	{
	5471	wxMutex mutex;
	5472	wxCondition condition(mutex);
	5473
	5474	// otherwise its difficult to understand which log messages pertain to
	5475	// which condition
	5476	//wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
	5477	// condition.GetId(), gs_cond.GetId());
	5478
	5479	// create and launch threads
	5480	MyWaitingThread *threads[10];
	5481
	5482	size_t n;
	5483	for ( n = 0; n < WXSIZEOF(threads); n++ )
	5484	{
	5485	threads[n] = new MyWaitingThread( &mutex, &condition );
	5486	}
	5487
	5488	for ( n = 0; n < WXSIZEOF(threads); n++ )
	5489	{
	5490	threads[n]->Run();
	5491	}
	5492
	5493	// wait until all threads run
	5494	wxPuts(_T("Main thread is waiting for the other threads to start"));
	5495	fflush(stdout);
	5496
	5497	size_t nRunning = 0;
	5498	while ( nRunning < WXSIZEOF(threads) )
	5499	{
	5500	gs_cond.Wait();
	5501
	5502	nRunning++;
	5503
	5504	wxPrintf(_T("Main thread: %u already running\n"), nRunning);
	5505	fflush(stdout);
	5506	}
	5507
	5508	wxPuts(_T("Main thread: all threads started up."));
	5509	fflush(stdout);
	5510
	5511	wxThread::Sleep(500);
	5512
	5513	#if 1
	5514	// now wake one of them up
	5515	wxPrintf(_T("Main thread: about to signal the condition.\n"));
	5516	fflush(stdout);
	5517	condition.Signal();
	5518	#endif
	5519
	5520	wxThread::Sleep(200);
	5521
	5522	// wake all the (remaining) threads up, so that they can exit
	5523	wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
	5524	fflush(stdout);
	5525	condition.Broadcast();
	5526
	5527	// give them time to terminate (dirty!)
	5528	wxThread::Sleep(500);
	5529	}
	5530
	5531	#include "wx/utils.h"
	5532
	5533	class MyExecThread : public wxThread
	5534	{
	5535	public:
	5536	MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
	5537	m_command(command)
	5538	{
	5539	Create();
	5540	}
	5541
	5542	virtual ExitCode Entry()
	5543	{
	5544	return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
	5545	}
	5546
	5547	private:
	5548	wxString m_command;
	5549	};
	5550
	5551	static void TestThreadExec()
	5552	{
	5553	wxPuts(_T("* Testing wxExecute interaction with threads *\n"));
	5554
	5555	MyExecThread thread(_T("true"));
	5556	thread.Run();
	5557
	5558	wxPrintf(_T("Main program exit code: %ld.\n"),
	5559	wxExecute(_T("false"), wxEXEC_SYNC));
	5560
	5561	wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
	5562	}
	5563
	5564	// semaphore tests
	5565	#include "wx/datetime.h"
	5566
	5567	class MySemaphoreThread : public wxThread
	5568	{
	5569	public:
	5570	MySemaphoreThread(int i, wxSemaphore *sem)
	5571	: wxThread(wxTHREAD_JOINABLE),
	5572	m_sem(sem),
	5573	m_i(i)
	5574	{
	5575	Create();
	5576	}
	5577
	5578	virtual ExitCode Entry()
	5579	{
	5580	wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
	5581	wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
	5582
	5583	m_sem->Wait();
	5584
	5585	wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
	5586	wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
	5587
	5588	Sleep(1000);
	5589
	5590	wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
	5591	wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
	5592
	5593	m_sem->Post();
	5594
	5595	return 0;
	5596	}
	5597
	5598	private:
	5599	wxSemaphore *m_sem;
	5600	int m_i;
	5601	};
	5602
	5603	WX_DEFINE_ARRAY(wxThread *, ArrayThreads);
	5604
	5605	static void TestSemaphore()
	5606	{
	5607	wxPuts(_T("* Testing wxSemaphore class. *"));
	5608
	5609	static const int SEM_LIMIT = 3;
	5610
	5611	wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
	5612	ArrayThreads threads;
	5613
	5614	for ( int i = 0; i < 3*SEM_LIMIT; i++ )
	5615	{
	5616	threads.Add(new MySemaphoreThread(i, &sem));
	5617	threads.Last()->Run();
	5618	}
	5619
	5620	for ( size_t n = 0; n < threads.GetCount(); n++ )
	5621	{
	5622	threads[n]->Wait();
	5623	delete threads[n];
	5624	}
	5625	}
	5626
	5627	#endif // TEST_THREADS
	5628
	5629	// ----------------------------------------------------------------------------
	5630	// arrays
	5631	// ----------------------------------------------------------------------------
	5632
	5633	#ifdef TEST_ARRAYS
	5634
	5635	#include "wx/dynarray.h"
	5636
	5637	typedef unsigned short ushort;
	5638
	5639	#define DefineCompare(name, T) \
	5640	\
	5641	int wxCMPFUNC_CONV name ## CompareValues(T first, T second) \
	5642	{ \
	5643	return first - second; \
	5644	} \
	5645	\
	5646	int wxCMPFUNC_CONV name ## Compare(T* first, T* second) \
	5647	{ \
	5648	return first - second; \
	5649	} \
	5650	\
	5651	int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second) \
	5652	{ \
	5653	return second - first; \
	5654	} \
	5655
	5656	DefineCompare(UShort, ushort);
	5657	DefineCompare(Int, int);
	5658
	5659	// test compilation of all macros
	5660	WX_DEFINE_ARRAY_SHORT(ushort, wxArrayUShort);
	5661	WX_DEFINE_SORTED_ARRAY_SHORT(ushort, wxSortedArrayUShortNoCmp);
	5662	WX_DEFINE_SORTED_ARRAY_CMP_SHORT(ushort, UShortCompareValues, wxSortedArrayUShort);
	5663	WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt);
	5664
	5665	WX_DECLARE_OBJARRAY(Bar, ArrayBars);
	5666	#include "wx/arrimpl.cpp"
	5667	WX_DEFINE_OBJARRAY(ArrayBars);
	5668
	5669	static void PrintArray(const wxChar* name, const wxArrayString& array)
	5670	{
	5671	wxPrintf(_T("Dump of the array '%s'\n"), name);
	5672
	5673	size_t nCount = array.GetCount();
	5674	for ( size_t n = 0; n < nCount; n++ )
	5675	{
	5676	wxPrintf(_T("\t%s[%u] = '%s'\n"), name, n, array[n].c_str());
	5677	}
	5678	}
	5679
	5680	int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
	5681	const wxString& second)
	5682	{
	5683	return first.length() - second.length();
	5684	}
	5685
	5686	#define TestArrayOf(name) \
	5687	\
	5688	static void PrintArray(const wxChar* name, const wxSortedArray##name & array) \
	5689	{ \
	5690	wxPrintf(_T("Dump of the array '%s'\n"), name); \
	5691	\
	5692	size_t nCount = array.GetCount(); \
	5693	for ( size_t n = 0; n < nCount; n++ ) \
	5694	{ \
	5695	wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]); \
	5696	} \
	5697	} \
	5698	\
	5699	static void PrintArray(const wxChar* name, const wxArray##name & array) \
	5700	{ \
	5701	wxPrintf(_T("Dump of the array '%s'\n"), name); \
	5702	\
	5703	size_t nCount = array.GetCount(); \
	5704	for ( size_t n = 0; n < nCount; n++ ) \
	5705	{ \
	5706	wxPrintf(_T("\t%s[%u] = %d\n"), name, n, array[n]); \
	5707	} \
	5708	} \
	5709	\
	5710	static void TestArrayOf ## name ## s() \
	5711	{ \
	5712	wxPrintf(_T("* Testing wxArray%s *\n"), #name); \
	5713	\
	5714	wxArray##name a; \
	5715	a.Add(1); \
	5716	a.Add(17,2); \
	5717	a.Add(5,3); \
	5718	a.Add(3,4); \
	5719	\
	5720	wxPuts(_T("Initially:")); \
	5721	PrintArray(_T("a"), a); \
	5722	\
	5723	wxPuts(_T("After sort:")); \
	5724	a.Sort(name ## Compare); \
	5725	PrintArray(_T("a"), a); \
	5726	\
	5727	wxPuts(_T("After reverse sort:")); \
	5728	a.Sort(name ## RevCompare); \
	5729	PrintArray(_T("a"), a); \
	5730	\
	5731	wxSortedArray##name b; \
	5732	b.Add(1); \
	5733	b.Add(17); \
	5734	b.Add(5); \
	5735	b.Add(3); \
	5736	\
	5737	wxPuts(_T("Sorted array initially:")); \
	5738	PrintArray(_T("b"), b); \
	5739	}
	5740
	5741	TestArrayOf(UShort);
	5742	TestArrayOf(Int);
	5743
	5744	static void TestArrayOfObjects()
	5745	{
	5746	wxPuts(_T("* Testing wxObjArray *\n"));
	5747
	5748	{
	5749	ArrayBars bars;
	5750	Bar bar("second bar (two copies!)");
	5751
	5752	wxPrintf(_T("Initially: %u objects in the array, %u objects total.\n"),
	5753	bars.GetCount(), Bar::GetNumber());
	5754
	5755	bars.Add(new Bar("first bar"));
	5756	bars.Add(bar,2);
	5757
	5758	wxPrintf(_T("Now: %u objects in the array, %u objects total.\n"),
	5759	bars.GetCount(), Bar::GetNumber());
	5760
	5761	bars.RemoveAt(1, bars.GetCount() - 1);
	5762
	5763	wxPrintf(_T("After removing all but first element: %u objects in the ")
	5764	_T("array, %u objects total.\n"),
	5765	bars.GetCount(), Bar::GetNumber());
	5766
	5767	bars.Empty();
	5768
	5769	wxPrintf(_T("After Empty(): %u objects in the array, %u objects total.\n"),
	5770	bars.GetCount(), Bar::GetNumber());
	5771	}
	5772
	5773	wxPrintf(_T("Finally: no more objects in the array, %u objects total.\n"),
	5774	Bar::GetNumber());
	5775	}
	5776
	5777	#endif // TEST_ARRAYS
	5778
	5779	// ----------------------------------------------------------------------------
	5780	// strings
	5781	// ----------------------------------------------------------------------------
	5782
	5783	#ifdef TEST_STRINGS
	5784
	5785	#include "wx/timer.h"
	5786	#include "wx/tokenzr.h"
	5787
	5788	static void TestStringConstruction()
	5789	{
	5790	wxPuts(_T("* Testing wxString constructores *"));
	5791
	5792	#define TEST_CTOR(args, res) \
	5793	{ \
	5794	wxString s args ; \
	5795	wxPrintf(_T("wxString%s = %s "), #args, s.c_str()); \
	5796	if ( s == res ) \
	5797	{ \
	5798	wxPuts(_T("(ok)")); \
	5799	} \
	5800	else \
	5801	{ \
	5802	wxPrintf(_T("(ERROR: should be %s)\n"), res); \
	5803	} \
	5804	}
	5805
	5806	TEST_CTOR((_T('Z'), 4), _T("ZZZZ"));
	5807	TEST_CTOR((_T("Hello"), 4), _T("Hell"));
	5808	TEST_CTOR((_T("Hello"), 5), _T("Hello"));
	5809	// TEST_CTOR((_T("Hello"), 6), _T("Hello")); -- should give assert failure
	5810
	5811	static const wxChar *s = _T("?really!");
	5812	const wxChar *start = wxStrchr(s, _T('r'));
	5813	const wxChar *end = wxStrchr(s, _T('!'));
	5814	TEST_CTOR((start, end), _T("really"));
	5815
	5816	wxPuts(_T(""));
	5817	}
	5818
	5819	static void TestString()
	5820	{
	5821	wxStopWatch sw;
	5822
	5823	wxString a, b, c;
	5824
	5825	a.reserve (128);
	5826	b.reserve (128);
	5827	c.reserve (128);
	5828
	5829	for (int i = 0; i < 1000000; ++i)
	5830	{
	5831	a = "Hello";
	5832	b = " world";
	5833	c = "! How'ya doin'?";
	5834	a += b;
	5835	a += c;
	5836	c = "Hello world! What's up?";
	5837	if (c != a)
	5838	c = "Doh!";
	5839	}
	5840
	5841	wxPrintf(_T("TestString elapsed time: %ld\n"), sw.Time());
	5842	}
	5843
	5844	static void TestPChar()
	5845	{
	5846	wxStopWatch sw;
	5847
	5848	wxChar a [128];
	5849	wxChar b [128];
	5850	wxChar c [128];
	5851
	5852	for (int i = 0; i < 1000000; ++i)
	5853	{
	5854	wxStrcpy (a, _T("Hello"));
	5855	wxStrcpy (b, _T(" world"));
	5856	wxStrcpy (c, _T("! How'ya doin'?"));
	5857	wxStrcat (a, b);
	5858	wxStrcat (a, c);
	5859	wxStrcpy (c, _T("Hello world! What's up?"));
	5860	if (wxStrcmp (c, a) == 0)
	5861	wxStrcpy (c, _T("Doh!"));
	5862	}
	5863
	5864	wxPrintf(_T("TestPChar elapsed time: %ld\n"), sw.Time());
	5865	}
	5866
	5867	static void TestStringSub()
	5868	{
	5869	wxString s("Hello, world!");
	5870
	5871	wxPuts(_T("* Testing wxString substring extraction *"));
	5872
	5873	wxPrintf(_T("String = '%s'\n"), s.c_str());
	5874	wxPrintf(_T("Left(5) = '%s'\n"), s.Left(5).c_str());
	5875	wxPrintf(_T("Right(6) = '%s'\n"), s.Right(6).c_str());
	5876	wxPrintf(_T("Mid(3, 5) = '%s'\n"), s(3, 5).c_str());
	5877	wxPrintf(_T("Mid(3) = '%s'\n"), s.Mid(3).c_str());
	5878	wxPrintf(_T("substr(3, 5) = '%s'\n"), s.substr(3, 5).c_str());
	5879	wxPrintf(_T("substr(3) = '%s'\n"), s.substr(3).c_str());
	5880
	5881	static const wxChar *prefixes[] =
	5882	{
	5883	_T("Hello"),
	5884	_T("Hello, "),
	5885	_T("Hello, world!"),
	5886	_T("Hello, world!!!"),
	5887	_T(""),
	5888	_T("Goodbye"),
	5889	_T("Hi"),
	5890	};
	5891
	5892	for ( size_t n = 0; n < WXSIZEOF(prefixes); n++ )
	5893	{
	5894	wxString prefix = prefixes[n], rest;
	5895	bool rc = s.StartsWith(prefix, &rest);
	5896	wxPrintf(_T("StartsWith('%s') = %s"), prefix.c_str(), rc ? _T("TRUE") : _T("FALSE"));
	5897	if ( rc )
	5898	{
	5899	wxPrintf(_T(" (the rest is '%s')\n"), rest.c_str());
	5900	}
	5901	else
	5902	{
	5903	putchar('\n');
	5904	}
	5905	}
	5906
	5907	wxPuts(_T(""));
	5908	}
	5909
	5910	static void TestStringFormat()
	5911	{
	5912	wxPuts(_T("* Testing wxString formatting *"));
	5913
	5914	wxString s;
	5915	s.Printf(_T("%03d"), 18);
	5916
	5917	wxPrintf(_T("Number 18: %s\n"), wxString::Format(_T("%03d"), 18).c_str());
	5918	wxPrintf(_T("Number 18: %s\n"), s.c_str());
	5919
	5920	wxPuts(_T(""));
	5921	}
	5922
	5923	// returns "not found" for npos, value for all others
	5924	static wxString PosToString(size_t res)
	5925	{
	5926	wxString s = res == wxString::npos ? wxString(_T("not found"))
	5927	: wxString::Format(_T("%u"), res);
	5928	return s;
	5929	}
	5930
	5931	static void TestStringFind()
	5932	{
	5933	wxPuts(_T("* Testing wxString find() functions *"));
	5934
	5935	static const wxChar *strToFind = _T("ell");
	5936	static const struct StringFindTest
	5937	{
	5938	const wxChar *str;
	5939	size_t start,
	5940	result; // of searching "ell" in str
	5941	} findTestData[] =
	5942	{
	5943	{ _T("Well, hello world"), 0, 1 },
	5944	{ _T("Well, hello world"), 6, 7 },
	5945	{ _T("Well, hello world"), 9, wxString::npos },
	5946	};
	5947
	5948	for ( size_t n = 0; n < WXSIZEOF(findTestData); n++ )
	5949	{
	5950	const StringFindTest& ft = findTestData[n];
	5951	size_t res = wxString(ft.str).find(strToFind, ft.start);
	5952
	5953	wxPrintf(_T("Index of '%s' in '%s' starting from %u is %s "),
	5954	strToFind, ft.str, ft.start, PosToString(res).c_str());
	5955
	5956	size_t resTrue = ft.result;
	5957	if ( res == resTrue )
	5958	{
	5959	wxPuts(_T("(ok)"));
	5960	}
	5961	else
	5962	{
	5963	wxPrintf(_T("(ERROR: should be %s)\n"),
	5964	PosToString(resTrue).c_str());
	5965	}
	5966	}
	5967
	5968	wxPuts(_T(""));
	5969	}
	5970
	5971	static void TestStringTokenizer()
	5972	{
	5973	wxPuts(_T("* Testing wxStringTokenizer *"));
	5974
	5975	static const wxChar *modeNames[] =
	5976	{
	5977	_T("default"),
	5978	_T("return empty"),
	5979	_T("return all empty"),
	5980	_T("with delims"),
	5981	_T("like strtok"),
	5982	};
	5983
	5984	static const struct StringTokenizerTest
	5985	{
	5986	const wxChar *str; // string to tokenize
	5987	const wxChar *delims; // delimiters to use
	5988	size_t count; // count of token
	5989	wxStringTokenizerMode mode; // how should we tokenize it
	5990	} tokenizerTestData[] =
	5991	{
	5992	{ _T(""), _T(" "), 0 },
	5993	{ _T("Hello, world"), _T(" "), 2 },
	5994	{ _T("Hello, world "), _T(" "), 2 },
	5995	{ _T("Hello, world"), _T(","), 2 },
	5996	{ _T("Hello, world!"), _T(",!"), 2 },
	5997	{ _T("Hello,, world!"), _T(",!"), 3 },
	5998	{ _T("Hello, world!"), _T(",!"), 3, wxTOKEN_RET_EMPTY_ALL },
	5999	{ _T("username:password:uid:gid:gecos:home:shell"), _T(":"), 7 },
	6000	{ _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 4 },
	6001	{ _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 6, wxTOKEN_RET_EMPTY },
	6002	{ _T("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, 9, wxTOKEN_RET_EMPTY_ALL },
	6003	{ _T("01/02/99"), _T("/-"), 3 },
	6004	{ _T("01-02/99"), _T("/-"), 3, wxTOKEN_RET_DELIMS },
	6005	};
	6006
	6007	for ( size_t n = 0; n < WXSIZEOF(tokenizerTestData); n++ )
	6008	{
	6009	const StringTokenizerTest& tt = tokenizerTestData[n];
	6010	wxStringTokenizer tkz(tt.str, tt.delims, tt.mode);
	6011
	6012	size_t count = tkz.CountTokens();
	6013	wxPrintf(_T("String '%s' has %u tokens delimited by '%s' (mode = %s) "),
	6014	MakePrintable(tt.str).c_str(),
	6015	count,
	6016	MakePrintable(tt.delims).c_str(),
	6017	modeNames[tkz.GetMode()]);
	6018	if ( count == tt.count )
	6019	{
	6020	wxPuts(_T("(ok)"));
	6021	}
	6022	else
	6023	{
	6024	wxPrintf(_T("(ERROR: should be %u)\n"), tt.count);
	6025
	6026	continue;
	6027	}
	6028
	6029	// if we emulate strtok(), check that we do it correctly
	6030	wxChar buf, s = NULL, *last;
	6031
	6032	if ( tkz.GetMode() == wxTOKEN_STRTOK )
	6033	{
	6034	buf = new wxChar[wxStrlen(tt.str) + 1];
	6035	wxStrcpy(buf, tt.str);
	6036
	6037	s = wxStrtok(buf, tt.delims, &last);
	6038	}
	6039	else
	6040	{
	6041	buf = NULL;
	6042	}
	6043
	6044	// now show the tokens themselves
	6045	size_t count2 = 0;
	6046	while ( tkz.HasMoreTokens() )
	6047	{
	6048	wxString token = tkz.GetNextToken();
	6049
	6050	wxPrintf(_T("\ttoken %u: '%s'"),
	6051	++count2,
	6052	MakePrintable(token).c_str());
	6053
	6054	if ( buf )
	6055	{
	6056	if ( token == s )
	6057	{
	6058	wxPuts(_T(" (ok)"));
	6059	}
	6060	else
	6061	{
	6062	wxPrintf(_T(" (ERROR: should be %s)\n"), s);
	6063	}
	6064
	6065	s = wxStrtok(NULL, tt.delims, &last);
	6066	}
	6067	else
	6068	{
	6069	// nothing to compare with
	6070	wxPuts(_T(""));
	6071	}
	6072	}
	6073
	6074	if ( count2 != count )
	6075	{
	6076	wxPuts(_T("\tERROR: token count mismatch"));
	6077	}
	6078
	6079	delete [] buf;
	6080	}
	6081
	6082	wxPuts(_T(""));
	6083	}
	6084
	6085	static void TestStringReplace()
	6086	{
	6087	wxPuts(_T("* Testing wxString::replace *"));
	6088
	6089	static const struct StringReplaceTestData
	6090	{
	6091	const wxChar *original; // original test string
	6092	size_t start, len; // the part to replace
	6093	const wxChar *replacement; // the replacement string
	6094	const wxChar *result; // and the expected result
	6095	} stringReplaceTestData[] =
	6096	{
	6097	{ _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") },
	6098	{ _T("increase"), 0, 2, _T("de"), _T("decrease") },
	6099	{ _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") },
	6100	{ _T("foobar"), 3, 0, _T("-"), _T("foo-bar") },
	6101	{ _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") },
	6102	};
	6103
	6104	for ( size_t n = 0; n < WXSIZEOF(stringReplaceTestData); n++ )
	6105	{
	6106	const StringReplaceTestData data = stringReplaceTestData[n];
	6107
	6108	wxString original = data.original;
	6109	original.replace(data.start, data.len, data.replacement);
	6110
	6111	wxPrintf(_T("wxString(\"%s\").replace(%u, %u, %s) = %s "),
	6112	data.original, data.start, data.len, data.replacement,
	6113	original.c_str());
	6114
	6115	if ( original == data.result )
	6116	{
	6117	wxPuts(_T("(ok)"));
	6118	}
	6119	else
	6120	{
	6121	wxPrintf(_T("(ERROR: should be '%s')\n"), data.result);
	6122	}
	6123	}
	6124
	6125	wxPuts(_T(""));
	6126	}
	6127
	6128	static void TestStringMatch()
	6129	{
	6130	wxPuts(_T("* Testing wxString::Matches() *"));
	6131
	6132	static const struct StringMatchTestData
	6133	{
	6134	const wxChar *text;
	6135	const wxChar *wildcard;
	6136	bool matches;
	6137	} stringMatchTestData[] =
	6138	{
	6139	{ _T("foobar"), _T("foo*"), 1 },
	6140	{ _T("foobar"), _T("oo"), 1 },
	6141	{ _T("foobar"), _T("*bar"), 1 },
	6142	{ _T("foobar"), _T("??????"), 1 },
	6143	{ _T("foobar"), _T("f??b*"), 1 },
	6144	{ _T("foobar"), _T("f?b*"), 0 },
	6145	{ _T("foobar"), _T("goo"), 0 },
	6146	{ _T("foobar"), _T("*foo"), 0 },
	6147	{ _T("foobarfoo"), _T("*foo"), 1 },
	6148	{ _T(""), _T("*"), 1 },
	6149	{ _T(""), _T("?"), 0 },
	6150	};
	6151
	6152	for ( size_t n = 0; n < WXSIZEOF(stringMatchTestData); n++ )
	6153	{
	6154	const StringMatchTestData& data = stringMatchTestData[n];
	6155	bool matches = wxString(data.text).Matches(data.wildcard);
	6156	wxPrintf(_T("'%s' %s '%s' (%s)\n"),
	6157	data.wildcard,
	6158	matches ? _T("matches") : _T("doesn't match"),
	6159	data.text,
	6160	matches == data.matches ? _T("ok") : _T("ERROR"));
	6161	}
	6162
	6163	wxPuts(_T(""));
	6164	}
	6165
	6166	#endif // TEST_STRINGS
	6167
	6168	// ----------------------------------------------------------------------------
	6169	// entry point
	6170	// ----------------------------------------------------------------------------
	6171
	6172	#ifdef TEST_SNGLINST
	6173	#include "wx/snglinst.h"
	6174	#endif // TEST_SNGLINST
	6175
	6176	int main(int argc, char **argv)
	6177	{
	6178	wxApp::CheckBuildOptions(wxBuildOptions());
	6179
	6180	wxInitializer initializer;
	6181	if ( !initializer )
	6182	{
	6183	fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
	6184
	6185	return -1;
	6186	}
	6187
	6188	#ifdef TEST_SNGLINST
	6189	wxSingleInstanceChecker checker;
	6190	if ( checker.Create(_T(".wxconsole.lock")) )
	6191	{
	6192	if ( checker.IsAnotherRunning() )
	6193	{
	6194	wxPrintf(_T("Another instance of the program is running, exiting.\n"));
	6195
	6196	return 1;
	6197	}
	6198
	6199	// wait some time to give time to launch another instance
	6200	wxPrintf(_T("Press \"Enter\" to continue..."));
	6201	wxFgetc(stdin);
	6202	}
	6203	else // failed to create
	6204	{
	6205	wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
	6206	}
	6207	#endif // TEST_SNGLINST
	6208
	6209	#ifdef TEST_CHARSET
	6210	TestCharset();
	6211	#endif // TEST_CHARSET
	6212
	6213	#ifdef TEST_CMDLINE
	6214	TestCmdLineConvert();
	6215
	6216	#if wxUSE_CMDLINE_PARSER
	6217	static const wxCmdLineEntryDesc cmdLineDesc[] =
	6218	{
	6219	{ wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
	6220	wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
	6221	{ wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
	6222	{ wxCMD_LINE_SWITCH, _T("q"), _T("quiet"), _T("be quiet") },
	6223
	6224	{ wxCMD_LINE_OPTION, _T("o"), _T("output"), _T("output file") },
	6225	{ wxCMD_LINE_OPTION, _T("i"), _T("input"), _T("input dir") },
	6226	{ wxCMD_LINE_OPTION, _T("s"), _T("size"), _T("output block size"),
	6227	wxCMD_LINE_VAL_NUMBER },
	6228	{ wxCMD_LINE_OPTION, _T("d"), _T("date"), _T("output file date"),
	6229	wxCMD_LINE_VAL_DATE },
	6230
	6231	{ wxCMD_LINE_PARAM, NULL, NULL, _T("input file"),
	6232	wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
	6233
	6234	{ wxCMD_LINE_NONE }
	6235	};
	6236
	6237	#if wxUSE_UNICODE
	6238	wxChar *wargv = new wxChar [argc + 1];
	6239
	6240	{
	6241	for ( int n = 0; n < argc; n++ )
	6242	{
	6243	wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
	6244	wargv[n] = wxStrdup(warg);
	6245	}
	6246
	6247	wargv[n] = NULL;
	6248	}
	6249
	6250	#define argv wargv
	6251	#endif // wxUSE_UNICODE
	6252
	6253	wxCmdLineParser parser(cmdLineDesc, argc, argv);
	6254
	6255	#if wxUSE_UNICODE
	6256	{
	6257	for ( int n = 0; n < argc; n++ )
	6258	free(wargv[n]);
	6259
	6260	delete [] wargv;
	6261	}
	6262	#endif // wxUSE_UNICODE
	6263
	6264	parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
	6265	wxCMD_LINE_VAL_STRING,
	6266	wxCMD_LINE_OPTION_MANDATORY \| wxCMD_LINE_NEEDS_SEPARATOR);
	6267
	6268	switch ( parser.Parse() )
	6269	{
	6270	case -1:
	6271	wxLogMessage(_T("Help was given, terminating."));
	6272	break;
	6273
	6274	case 0:
	6275	ShowCmdLine(parser);
	6276	break;
	6277
	6278	default:
	6279	wxLogMessage(_T("Syntax error detected, aborting."));
	6280	break;
	6281	}
	6282	#endif // wxUSE_CMDLINE_PARSER
	6283
	6284	#endif // TEST_CMDLINE
	6285
	6286	#ifdef TEST_STRINGS
	6287	if ( TEST_ALL )
	6288	{
	6289	TestPChar();
	6290	TestString();
	6291	TestStringSub();
	6292	TestStringConstruction();
	6293	TestStringFormat();
	6294	TestStringFind();
	6295	TestStringTokenizer();
	6296	TestStringReplace();
	6297	}
	6298	else
	6299	{
	6300	TestStringMatch();
	6301	}
	6302	#endif // TEST_STRINGS
	6303
	6304	#ifdef TEST_ARRAYS
	6305	if ( TEST_ALL )
	6306	{
	6307	wxArrayString a1;
	6308	a1.Add(_T("tiger"));
	6309	a1.Add(_T("cat"));
	6310	a1.Add(_T("lion"), 3);
	6311	a1.Add(_T("dog"));
	6312	a1.Add(_T("human"));
	6313	a1.Add(_T("ape"));
	6314
	6315	wxPuts(_T("*** Initially:"));
	6316
	6317	PrintArray(_T("a1"), a1);
	6318
	6319	wxArrayString a2(a1);
	6320	PrintArray(_T("a2"), a2);
	6321
	6322	wxSortedArrayString a3(a1);
	6323	PrintArray(_T("a3"), a3);
	6324
	6325	wxPuts(_T("*** After deleting three strings from a1"));
	6326	a1.Remove(2,3);
	6327
	6328	PrintArray(_T("a1"), a1);
	6329	PrintArray(_T("a2"), a2);
	6330	PrintArray(_T("a3"), a3);
	6331
	6332	wxPuts(_T("*** After reassigning a1 to a2 and a3"));
	6333	a3 = a2 = a1;
	6334	PrintArray(_T("a2"), a2);
	6335	PrintArray(_T("a3"), a3);
	6336
	6337	wxPuts(_T("*** After sorting a1"));
	6338	a1.Sort();
	6339	PrintArray(_T("a1"), a1);
	6340
	6341	wxPuts(_T("*** After sorting a1 in reverse order"));
	6342	a1.Sort(TRUE);
	6343	PrintArray(_T("a1"), a1);
	6344
	6345	wxPuts(_T("*** After sorting a1 by the string length"));
	6346	a1.Sort(StringLenCompare);
	6347	PrintArray(_T("a1"), a1);
	6348
	6349	TestArrayOfObjects();
	6350	TestArrayOfUShorts();
	6351	}
	6352
	6353	TestArrayOfInts();
	6354	#endif // TEST_ARRAYS
	6355
	6356	#ifdef TEST_DIR
	6357	if ( TEST_ALL )
	6358	{
	6359	TestDirExists();
	6360	TestDirTraverse();
	6361	}
	6362	TestDirEnum();
	6363	#endif // TEST_DIR
	6364
	6365	#ifdef TEST_DLLLOADER
	6366	TestDllLoad();
	6367	#endif // TEST_DLLLOADER
	6368
	6369	#ifdef TEST_ENVIRON
	6370	TestEnvironment();
	6371	#endif // TEST_ENVIRON
	6372
	6373	#ifdef TEST_EXECUTE
	6374	TestExecute();
	6375	#endif // TEST_EXECUTE
	6376
	6377	#ifdef TEST_FILECONF
	6378	TestFileConfRead();
	6379	#endif // TEST_FILECONF
	6380
	6381	#ifdef TEST_LIST
	6382	TestListCtor();
	6383	#endif // TEST_LIST
	6384
	6385	#ifdef TEST_LOCALE
	6386	TestDefaultLang();
	6387	#endif // TEST_LOCALE
	6388
	6389	#ifdef TEST_LOG
	6390	wxString s;
	6391	for ( size_t n = 0; n < 8000; n++ )
	6392	{
	6393	s << (wxChar)(_T('A') + (n % 26));
	6394	}
	6395
	6396	wxString msg;
	6397	msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
	6398
	6399	// this one shouldn't be truncated
	6400	wxPrintf(msg);
	6401
	6402	// but this one will because log functions use fixed size buffer
	6403	// (note that it doesn't need '\n' at the end neither - will be added
	6404	// by wxLog anyhow)
	6405	wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
	6406	#endif // TEST_LOG
	6407
	6408	#ifdef TEST_FILE
	6409	if ( TEST_ALL )
	6410	{
	6411	TestFileRead();
	6412	TestTextFileRead();
	6413	TestFileCopy();
	6414	}
	6415	#endif // TEST_FILE
	6416
	6417	#ifdef TEST_FILENAME
	6418	if ( 0 )
	6419	{
	6420	wxFileName fn;
	6421	fn.Assign(_T("c:\\foo"), _T("bar.baz"));
	6422	fn.Assign(_T("/u/os9-port/Viewer/tvision/WEI2HZ-3B3-14_05-04-00MSC1.asc"));
	6423
	6424	DumpFileName(fn);
	6425	}
	6426
	6427	TestFileNameConstruction();
	6428	if ( TEST_ALL )
	6429	{
	6430	TestFileNameConstruction();
	6431	TestFileNameMakeRelative();
	6432	TestFileNameSplit();
	6433	TestFileNameTemp();
	6434	TestFileNameCwd();
	6435	TestFileNameComparison();
	6436	TestFileNameOperations();
	6437	}
	6438	#endif // TEST_FILENAME
	6439
	6440	#ifdef TEST_FILETIME
	6441	TestFileGetTimes();
	6442	if ( 0 )
	6443	TestFileSetTimes();
	6444	#endif // TEST_FILETIME
	6445
	6446	#ifdef TEST_FTP
	6447	wxLog::AddTraceMask(FTP_TRACE_MASK);
	6448	if ( TestFtpConnect() )
	6449	{
	6450	if ( TEST_ALL )
	6451	{
	6452	TestFtpList();
	6453	TestFtpDownload();
	6454	TestFtpMisc();
	6455	TestFtpFileSize();
	6456	TestFtpUpload();
	6457	}
	6458
	6459	if ( TEST_INTERACTIVE )
	6460	TestFtpInteractive();
	6461	}
	6462	//else: connecting to the FTP server failed
	6463
	6464	if ( 0 )
	6465	TestFtpWuFtpd();
	6466	#endif // TEST_FTP
	6467
	6468	#ifdef TEST_LONGLONG
	6469	// seed pseudo random generator
	6470	srand((unsigned)time(NULL));
	6471
	6472	if ( 0 )
	6473	{
	6474	TestSpeed();
	6475	}
	6476
	6477	if ( TEST_ALL )
	6478	{
	6479	TestMultiplication();
	6480	TestDivision();
	6481	TestAddition();
	6482	TestLongLongConversion();
	6483	TestBitOperations();
	6484	TestLongLongComparison();
	6485	TestLongLongToString();
	6486	TestLongLongPrintf();
	6487	}
	6488	#endif // TEST_LONGLONG
	6489
	6490	#ifdef TEST_HASH
	6491	TestHash();
	6492	#endif // TEST_HASH
	6493
	6494	#ifdef TEST_HASHMAP
	6495	TestHashMap();
	6496	#endif // TEST_HASHMAP
	6497
	6498	#ifdef TEST_MIME
	6499	wxLog::AddTraceMask(_T("mime"));
	6500	if ( TEST_ALL )
	6501	{
	6502	TestMimeEnum();
	6503	TestMimeOverride();
	6504	TestMimeAssociate();
	6505	}
	6506	TestMimeFilename();
	6507	#endif // TEST_MIME
	6508
	6509	#ifdef TEST_INFO_FUNCTIONS
	6510	if ( TEST_ALL )
	6511	{
	6512	TestOsInfo();
	6513	TestUserInfo();
	6514
	6515	if ( TEST_INTERACTIVE )
	6516	TestDiskInfo();
	6517	}
	6518	#endif // TEST_INFO_FUNCTIONS
	6519
	6520	#ifdef TEST_PATHLIST
	6521	TestPathList();
	6522	#endif // TEST_PATHLIST
	6523
	6524	#ifdef TEST_ODBC
	6525	TestDbOpen();
	6526	#endif // TEST_ODBC
	6527
	6528	#ifdef TEST_PRINTF
	6529	TestPrintf();
	6530	#endif // TEST_PRINTF
	6531
	6532	#ifdef TEST_REGCONF
	6533	TestRegConfWrite();
	6534	#endif // TEST_REGCONF
	6535
	6536	#ifdef TEST_REGEX
	6537	// TODO: write a real test using src/regex/tests file
	6538	if ( TEST_ALL )
	6539	{
	6540	TestRegExCompile();
	6541	TestRegExMatch();
	6542	TestRegExSubmatch();
	6543	TestRegExReplacement();
	6544
	6545	if ( TEST_INTERACTIVE )
	6546	TestRegExInteractive();
	6547	}
	6548	#endif // TEST_REGEX
	6549
	6550	#ifdef TEST_REGISTRY
	6551	TestRegistryRead();
	6552	TestRegistryAssociation();
	6553	#endif // TEST_REGISTRY
	6554
	6555	#ifdef TEST_SOCKETS
	6556	TestSocketServer();
	6557	TestSocketClient();
	6558	#endif // TEST_SOCKETS
	6559
	6560	#ifdef TEST_STREAMS
	6561	if ( TEST_ALL )
	6562	{
	6563	TestFileStream();
	6564	}
	6565	TestMemoryStream();
	6566	#endif // TEST_STREAMS
	6567
	6568	#ifdef TEST_TEXTSTREAM
	6569	TestTextInputStream();
	6570	#endif // TEST_TEXTSTREAM
	6571
	6572	#ifdef TEST_THREADS
	6573	int nCPUs = wxThread::GetCPUCount();
	6574	wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
	6575	if ( nCPUs != -1 )
	6576	wxThread::SetConcurrency(nCPUs);
	6577
	6578	TestDetachedThreads();
	6579	if ( TEST_ALL )
	6580	{
	6581	TestJoinableThreads();
	6582	TestThreadSuspend();
	6583	TestThreadDelete();
	6584	TestThreadConditions();
	6585	TestThreadExec();
	6586	TestSemaphore();
	6587	}
	6588	#endif // TEST_THREADS
	6589
	6590	#ifdef TEST_TIMER
	6591	TestStopWatch();
	6592	#endif // TEST_TIMER
	6593
	6594	#ifdef TEST_DATETIME
	6595	if ( TEST_ALL )
	6596	{
	6597	TestTimeSet();
	6598	TestTimeStatic();
	6599	TestTimeRange();
	6600	TestTimeZones();
	6601	TestTimeTicks();
	6602	TestTimeJDN();
	6603	TestTimeDST();
	6604	TestTimeWDays();
	6605	TestTimeWNumber();
	6606	TestTimeParse();
	6607	TestTimeArithmetics();
	6608	TestTimeHolidays();
	6609	TestTimeFormat();
	6610	TestTimeSpanFormat();
	6611	TestTimeMS();
	6612
	6613	TestTimeZoneBug();
	6614	}
	6615
	6616	TestTimeWNumber();
	6617
	6618	if ( TEST_INTERACTIVE )
	6619	TestDateTimeInteractive();
	6620	#endif // TEST_DATETIME
	6621
	6622	#ifdef TEST_USLEEP
	6623	wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
	6624	wxUsleep(3000);
	6625	#endif // TEST_USLEEP
	6626
	6627	#ifdef TEST_VCARD
	6628	TestVCardRead();
	6629	TestVCardWrite();
	6630	#endif // TEST_VCARD
	6631
	6632	#ifdef TEST_VOLUME
	6633	TestFSVolume();
	6634	#endif // TEST_VOLUME
	6635
	6636	#ifdef TEST_UNICODE
	6637	TestUnicodeToFromAscii();
	6638	#endif // TEST_UNICODE
	6639
	6640	#ifdef TEST_WCHAR
	6641	TestUtf8();
	6642	TestEncodingConverter();
	6643	#endif // TEST_WCHAR
	6644
	6645	#ifdef TEST_ZIP
	6646	TestZipStreamRead();
	6647	TestZipFileSystem();
	6648	#endif // TEST_ZIP
	6649
	6650	#ifdef TEST_ZLIB
	6651	TestZlibStreamWrite();
	6652	TestZlibStreamRead();
	6653	#endif // TEST_ZLIB
	6654
	6655	return 0;
	6656	}
	6657