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 wxWidgets
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 04.10.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#include "wx/defs.h"
	21
	22	#include <stdio.h>
	23
	24	#include "wx/string.h"
	25	#include "wx/file.h"
	26	#include "wx/app.h"
	27	#include "wx/log.h"
	28
	29	// without this pragma, the stupid compiler precompiles #defines below so that
	30	// changing them doesn't "take place" later!
	31	#ifdef __VISUALC__
	32	#pragma hdrstop
	33	#endif
	34
	35	// ----------------------------------------------------------------------------
	36	// conditional compilation
	37	// ----------------------------------------------------------------------------
	38
	39	/*
	40	A note about all these conditional compilation macros: this file is used
	41	both as a test suite for various non-GUI wxWidgets classes and as a
	42	scratchpad for quick tests. So there are two compilation modes: if you
	43	define TEST_ALL all tests are run, otherwise you may enable the individual
	44	tests individually in the "#else" branch below.
	45	*/
	46
	47	// what to test (in alphabetic order)? Define TEST_ALL to 0 to do a single
	48	// test, define it to 1 to do all tests.
	49	#define TEST_ALL 0
	50
	51
	52	#if TEST_ALL
	53
	54	#define TEST_CMDLINE
	55	#define TEST_DATETIME
	56	#define TEST_DIR
	57	#define TEST_DLLLOADER
	58	#define TEST_ENVIRON
	59	#define TEST_EXECUTE
	60	#define TEST_FILE
	61	#define TEST_FILECONF
	62	#define TEST_FILENAME
	63	#define TEST_FILETIME
	64	// #define TEST_FTP --FIXME! (RN)
	65	#define TEST_HASHMAP
	66	#define TEST_HASHSET
	67	#define TEST_INFO_FUNCTIONS
	68	#define TEST_LIST
	69	#define TEST_LOCALE
	70	#define TEST_LOG
	71	#define TEST_MIME
	72	#define TEST_PATHLIST
	73	#define TEST_ODBC
	74	#define TEST_PRINTF
	75	#define TEST_REGCONF
	76	#define TEST_REGEX
	77	#define TEST_REGISTRY
	78	#define TEST_SCOPEGUARD
	79	#define TEST_SNGLINST
	80	// #define TEST_SOCKETS --FIXME! (RN)
	81	#define TEST_STREAMS
	82	#define TEST_TEXTSTREAM
	83	#define TEST_THREADS
	84	#define TEST_TIMER
	85	// #define TEST_VCARD -- don't enable this (VZ)
	86	// #define TEST_VOLUME --FIXME! (RN)
	87	#define TEST_WCHAR
	88	#define TEST_ZIP
	89
	90	#else // #if TEST_ALL
	91
	92	#define TEST_DATETIME
	93
	94	#endif
	95
	96	// some tests are interactive, define this to run them
	97	#ifdef TEST_INTERACTIVE
	98	#undef TEST_INTERACTIVE
	99
	100	#define TEST_INTERACTIVE 1
	101	#else
	102	#define TEST_INTERACTIVE 0
	103	#endif
	104
	105	// ----------------------------------------------------------------------------
	106	// test class for container objects
	107	// ----------------------------------------------------------------------------
	108
	109	#if defined(TEST_LIST)
	110
	111	class Bar // Foo is already taken in the hash test
	112	{
	113	public:
	114	Bar(const wxString& name) : m_name(name) { ms_bars++; }
	115	Bar(const Bar& bar) : m_name(bar.m_name) { ms_bars++; }
	116	~Bar() { ms_bars--; }
	117
	118	static size_t GetNumber() { return ms_bars; }
	119
	120	const wxChar *GetName() const { return m_name; }
	121
	122	private:
	123	wxString m_name;
	124
	125	static size_t ms_bars;
	126	};
	127
	128	size_t Bar::ms_bars = 0;
	129
	130	#endif // defined(TEST_LIST)
	131
	132	// ============================================================================
	133	// implementation
	134	// ============================================================================
	135
	136	// ----------------------------------------------------------------------------
	137	// helper functions
	138	// ----------------------------------------------------------------------------
	139
	140	#if defined(TEST_SOCKETS)
	141
	142	// replace TABs with \t and CRs with \n
	143	static wxString MakePrintable(const wxChar *s)
	144	{
	145	wxString str(s);
	146	(void)str.Replace(_T("\t"), _T("\\t"));
	147	(void)str.Replace(_T("\n"), _T("\\n"));
	148	(void)str.Replace(_T("\r"), _T("\\r"));
	149
	150	return str;
	151	}
	152
	153	#endif // MakePrintable() is used
	154
	155	// ----------------------------------------------------------------------------
	156	// wxCmdLineParser
	157	// ----------------------------------------------------------------------------
	158
	159	#ifdef TEST_CMDLINE
	160
	161	#include "wx/cmdline.h"
	162	#include "wx/datetime.h"
	163
	164	#if wxUSE_CMDLINE_PARSER
	165
	166	static void ShowCmdLine(const wxCmdLineParser& parser)
	167	{
	168	wxString s = _T("Input files: ");
	169
	170	size_t count = parser.GetParamCount();
	171	for ( size_t param = 0; param < count; param++ )
	172	{
	173	s << parser.GetParam(param) << ' ';
	174	}
	175
	176	s << '\n'
	177	<< _T("Verbose:\t") << (parser.Found(_T("v")) ? _T("yes") : _T("no")) << '\n'
	178	<< _T("Quiet:\t") << (parser.Found(_T("q")) ? _T("yes") : _T("no")) << '\n';
	179
	180	wxString strVal;
	181	long lVal;
	182	wxDateTime dt;
	183	if ( parser.Found(_T("o"), &strVal) )
	184	s << _T("Output file:\t") << strVal << '\n';
	185	if ( parser.Found(_T("i"), &strVal) )
	186	s << _T("Input dir:\t") << strVal << '\n';
	187	if ( parser.Found(_T("s"), &lVal) )
	188	s << _T("Size:\t") << lVal << '\n';
	189	if ( parser.Found(_T("d"), &dt) )
	190	s << _T("Date:\t") << dt.FormatISODate() << '\n';
	191	if ( parser.Found(_T("project_name"), &strVal) )
	192	s << _T("Project:\t") << strVal << '\n';
	193
	194	wxLogMessage(s);
	195	}
	196
	197	#endif // wxUSE_CMDLINE_PARSER
	198
	199	static void TestCmdLineConvert()
	200	{
	201	static const wxChar *cmdlines[] =
	202	{
	203	_T("arg1 arg2"),
	204	_T("-a \"-bstring 1\" -c\"string 2\" \"string 3\""),
	205	_T("literal \\\" and \"\""),
	206	};
	207
	208	for ( size_t n = 0; n < WXSIZEOF(cmdlines); n++ )
	209	{
	210	const wxChar *cmdline = cmdlines[n];
	211	wxPrintf(_T("Parsing: %s\n"), cmdline);
	212	wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdline);
	213
	214	size_t count = args.GetCount();
	215	wxPrintf(_T("\targc = %u\n"), count);
	216	for ( size_t arg = 0; arg < count; arg++ )
	217	{
	218	wxPrintf(_T("\targv[%u] = %s\n"), arg, args[arg].c_str());
	219	}
	220	}
	221	}
	222
	223	#endif // TEST_CMDLINE
	224
	225	// ----------------------------------------------------------------------------
	226	// wxDir
	227	// ----------------------------------------------------------------------------
	228
	229	#ifdef TEST_DIR
	230
	231	#include "wx/dir.h"
	232
	233	#ifdef __UNIX__
	234	static const wxChar *ROOTDIR = _T("/");
	235	static const wxChar *TESTDIR = _T("/usr/local/share");
	236	#elif defined(__WXMSW__)
	237	static const wxChar *ROOTDIR = _T("c:\\");
	238	static const wxChar *TESTDIR = _T("d:\\");
	239	#else
	240	#error "don't know where the root directory is"
	241	#endif
	242
	243	static void TestDirEnumHelper(wxDir& dir,
	244	int flags = wxDIR_DEFAULT,
	245	const wxString& filespec = wxEmptyString)
	246	{
	247	wxString filename;
	248
	249	if ( !dir.IsOpened() )
	250	return;
	251
	252	bool cont = dir.GetFirst(&filename, filespec, flags);
	253	while ( cont )
	254	{
	255	wxPrintf(_T("\t%s\n"), filename.c_str());
	256
	257	cont = dir.GetNext(&filename);
	258	}
	259
	260	wxPuts(wxEmptyString);
	261	}
	262
	263	static void TestDirEnum()
	264	{
	265	wxPuts(_T("* Testing wxDir::GetFirst/GetNext *"));
	266
	267	wxString cwd = wxGetCwd();
	268	if ( !wxDir::Exists(cwd) )
	269	{
	270	wxPrintf(_T("ERROR: current directory '%s' doesn't exist?\n"), cwd.c_str());
	271	return;
	272	}
	273
	274	wxDir dir(cwd);
	275	if ( !dir.IsOpened() )
	276	{
	277	wxPrintf(_T("ERROR: failed to open current directory '%s'.\n"), cwd.c_str());
	278	return;
	279	}
	280
	281	wxPuts(_T("Enumerating everything in current directory:"));
	282	TestDirEnumHelper(dir);
	283
	284	wxPuts(_T("Enumerating really everything in current directory:"));
	285	TestDirEnumHelper(dir, wxDIR_DEFAULT \| wxDIR_DOTDOT);
	286
	287	wxPuts(_T("Enumerating object files in current directory:"));
	288	TestDirEnumHelper(dir, wxDIR_DEFAULT, _T(".o"));
	289
	290	wxPuts(_T("Enumerating directories in current directory:"));
	291	TestDirEnumHelper(dir, wxDIR_DIRS);
	292
	293	wxPuts(_T("Enumerating files in current directory:"));
	294	TestDirEnumHelper(dir, wxDIR_FILES);
	295
	296	wxPuts(_T("Enumerating files including hidden in current directory:"));
	297	TestDirEnumHelper(dir, wxDIR_FILES \| wxDIR_HIDDEN);
	298
	299	dir.Open(ROOTDIR);
	300
	301	wxPuts(_T("Enumerating everything in root directory:"));
	302	TestDirEnumHelper(dir, wxDIR_DEFAULT);
	303
	304	wxPuts(_T("Enumerating directories in root directory:"));
	305	TestDirEnumHelper(dir, wxDIR_DIRS);
	306
	307	wxPuts(_T("Enumerating files in root directory:"));
	308	TestDirEnumHelper(dir, wxDIR_FILES);
	309
	310	wxPuts(_T("Enumerating files including hidden in root directory:"));
	311	TestDirEnumHelper(dir, wxDIR_FILES \| wxDIR_HIDDEN);
	312
	313	wxPuts(_T("Enumerating files in non existing directory:"));
	314	wxDir dirNo(_T("nosuchdir"));
	315	TestDirEnumHelper(dirNo);
	316	}
	317
	318	class DirPrintTraverser : public wxDirTraverser
	319	{
	320	public:
	321	virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
	322	{
	323	return wxDIR_CONTINUE;
	324	}
	325
	326	virtual wxDirTraverseResult OnDir(const wxString& dirname)
	327	{
	328	wxString path, name, ext;
	329	wxSplitPath(dirname, &path, &name, &ext);
	330
	331	if ( !ext.empty() )
	332	name << _T('.') << ext;
	333
	334	wxString indent;
	335	for ( const wxChar p = path.c_str(); p; p++ )
	336	{
	337	if ( wxIsPathSeparator(*p) )
	338	indent += _T(" ");
	339	}
	340
	341	wxPrintf(_T("%s%s\n"), indent.c_str(), name.c_str());
	342
	343	return wxDIR_CONTINUE;
	344	}
	345	};
	346
	347	static void TestDirTraverse()
	348	{
	349	wxPuts(_T("* Testing wxDir::Traverse() *"));
	350
	351	// enum all files
	352	wxArrayString files;
	353	size_t n = wxDir::GetAllFiles(TESTDIR, &files);
	354	wxPrintf(_T("There are %u files under '%s'\n"), n, TESTDIR);
	355	if ( n > 1 )
	356	{
	357	wxPrintf(_T("First one is '%s'\n"), files[0u].c_str());
	358	wxPrintf(_T(" last one is '%s'\n"), files[n - 1].c_str());
	359	}
	360
	361	// enum again with custom traverser
	362	wxPuts(_T("Now enumerating directories:"));
	363	wxDir dir(TESTDIR);
	364	DirPrintTraverser traverser;
	365	dir.Traverse(traverser, wxEmptyString, wxDIR_DIRS \| wxDIR_HIDDEN);
	366	}
	367
	368	static void TestDirExists()
	369	{
	370	wxPuts(_T("* Testing wxDir::Exists() *"));
	371
	372	static const wxChar *dirnames[] =
	373	{
	374	_T("."),
	375	#if defined(__WXMSW__)
	376	_T("c:"),
	377	_T("c:\\"),
	378	_T("\\\\share\\file"),
	379	_T("c:\\dos"),
	380	_T("c:\\dos\\"),
	381	_T("c:\\dos\\\\"),
	382	_T("c:\\autoexec.bat"),
	383	#elif defined(__UNIX__)
	384	_T("/"),
	385	_T("//"),
	386	_T("/usr/bin"),
	387	_T("/usr//bin"),
	388	_T("/usr///bin"),
	389	#endif
	390	};
	391
	392	for ( size_t n = 0; n < WXSIZEOF(dirnames); n++ )
	393	{
	394	wxPrintf(_T("%-40s: %s\n"),
	395	dirnames[n],
	396	wxDir::Exists(dirnames[n]) ? _T("exists")
	397	: _T("doesn't exist"));
	398	}
	399	}
	400
	401	#endif // TEST_DIR
	402
	403	// ----------------------------------------------------------------------------
	404	// wxDllLoader
	405	// ----------------------------------------------------------------------------
	406
	407	#ifdef TEST_DLLLOADER
	408
	409	#include "wx/dynlib.h"
	410
	411	static void TestDllLoad()
	412	{
	413	#if defined(__WXMSW__)
	414	static const wxChar *LIB_NAME = _T("kernel32.dll");
	415	static const wxChar *FUNC_NAME = _T("lstrlenA");
	416	#elif defined(__UNIX__)
	417	// weird: using just libc.so does not work!
	418	static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
	419	static const wxChar *FUNC_NAME = _T("strlen");
	420	#else
	421	#error "don't know how to test wxDllLoader on this platform"
	422	#endif
	423
	424	wxPuts(_T("* testing wxDllLoader *\n"));
	425
	426	wxDynamicLibrary lib(LIB_NAME);
	427	if ( !lib.IsLoaded() )
	428	{
	429	wxPrintf(_T("ERROR: failed to load '%s'.\n"), LIB_NAME);
	430	}
	431	else
	432	{
	433	typedef int (wxStrlenType)(const char );
	434	wxStrlenType pfnStrlen = (wxStrlenType)lib.GetSymbol(FUNC_NAME);
	435	if ( !pfnStrlen )
	436	{
	437	wxPrintf(_T("ERROR: function '%s' wasn't found in '%s'.\n"),
	438	FUNC_NAME, LIB_NAME);
	439	}
	440	else
	441	{
	442	if ( pfnStrlen("foo") != 3 )
	443	{
	444	wxPrintf(_T("ERROR: loaded function is not wxStrlen()!\n"));
	445	}
	446	else
	447	{
	448	wxPuts(_T("... ok"));
	449	}
	450	}
	451	}
	452	}
	453
	454	#endif // TEST_DLLLOADER
	455
	456	// ----------------------------------------------------------------------------
	457	// wxGet/SetEnv
	458	// ----------------------------------------------------------------------------
	459
	460	#ifdef TEST_ENVIRON
	461
	462	#include "wx/utils.h"
	463
	464	static wxString MyGetEnv(const wxString& var)
	465	{
	466	wxString val;
	467	if ( !wxGetEnv(var, &val) )
	468	val = _T("<empty>");
	469	else
	470	val = wxString(_T('\'')) + val + _T('\'');
	471
	472	return val;
	473	}
	474
	475	static void TestEnvironment()
	476	{
	477	const wxChar *var = _T("wxTestVar");
	478
	479	wxPuts(_T("* testing environment access functions *"));
	480
	481	wxPrintf(_T("Initially getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	482	wxSetEnv(var, _T("value for wxTestVar"));
	483	wxPrintf(_T("After wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	484	wxSetEnv(var, _T("another value"));
	485	wxPrintf(_T("After 2nd wxSetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	486	wxUnsetEnv(var);
	487	wxPrintf(_T("After wxUnsetEnv: getenv(%s) = %s\n"), var, MyGetEnv(var).c_str());
	488	wxPrintf(_T("PATH = %s\n"), MyGetEnv(_T("PATH")).c_str());
	489	}
	490
	491	#endif // TEST_ENVIRON
	492
	493	// ----------------------------------------------------------------------------
	494	// wxExecute
	495	// ----------------------------------------------------------------------------
	496
	497	#ifdef TEST_EXECUTE
	498
	499	#include "wx/utils.h"
	500
	501	static void TestExecute()
	502	{
	503	wxPuts(_T("* testing wxExecute *"));
	504
	505	#ifdef __UNIX__
	506	#define COMMAND "cat -n ../../Makefile" // "echo hi"
	507	#define SHELL_COMMAND "echo hi from shell"
	508	#define REDIRECT_COMMAND COMMAND // "date"
	509	#elif defined(__WXMSW__)
	510	#define COMMAND "command.com /c echo hi"
	511	#define SHELL_COMMAND "echo hi"
	512	#define REDIRECT_COMMAND COMMAND
	513	#else
	514	#error "no command to exec"
	515	#endif // OS
	516
	517	wxPrintf(_T("Testing wxShell: "));
	518	fflush(stdout);
	519	if ( wxShell(_T(SHELL_COMMAND)) )
	520	wxPuts(_T("Ok."));
	521	else
	522	wxPuts(_T("ERROR."));
	523
	524	wxPrintf(_T("Testing wxExecute: "));
	525	fflush(stdout);
	526	if ( wxExecute(_T(COMMAND), true /* sync */) == 0 )
	527	wxPuts(_T("Ok."));
	528	else
	529	wxPuts(_T("ERROR."));
	530
	531	#if 0 // no, it doesn't work (yet?)
	532	wxPrintf(_T("Testing async wxExecute: "));
	533	fflush(stdout);
	534	if ( wxExecute(COMMAND) != 0 )
	535	wxPuts(_T("Ok (command launched)."));
	536	else
	537	wxPuts(_T("ERROR."));
	538	#endif // 0
	539
	540	wxPrintf(_T("Testing wxExecute with redirection:\n"));
	541	wxArrayString output;
	542	if ( wxExecute(_T(REDIRECT_COMMAND), output) != 0 )
	543	{
	544	wxPuts(_T("ERROR."));
	545	}
	546	else
	547	{
	548	size_t count = output.GetCount();
	549	for ( size_t n = 0; n < count; n++ )
	550	{
	551	wxPrintf(_T("\t%s\n"), output[n].c_str());
	552	}
	553
	554	wxPuts(_T("Ok."));
	555	}
	556	}
	557
	558	#endif // TEST_EXECUTE
	559
	560	// ----------------------------------------------------------------------------
	561	// file
	562	// ----------------------------------------------------------------------------
	563
	564	#ifdef TEST_FILE
	565
	566	#include "wx/file.h"
	567	#include "wx/ffile.h"
	568	#include "wx/textfile.h"
	569
	570	static void TestFileRead()
	571	{
	572	wxPuts(_T("* wxFile read test *"));
	573
	574	wxFile file(_T("testdata.fc"));
	575	if ( file.IsOpened() )
	576	{
	577	wxPrintf(_T("File length: %lu\n"), file.Length());
	578
	579	wxPuts(_T("File dump:\n----------"));
	580
	581	static const off_t len = 1024;
	582	wxChar buf[len];
	583	for ( ;; )
	584	{
	585	off_t nRead = file.Read(buf, len);
	586	if ( nRead == wxInvalidOffset )
	587	{
	588	wxPrintf(_T("Failed to read the file."));
	589	break;
	590	}
	591
	592	fwrite(buf, nRead, 1, stdout);
	593
	594	if ( nRead < len )
	595	break;
	596	}
	597
	598	wxPuts(_T("----------"));
	599	}
	600	else
	601	{
	602	wxPrintf(_T("ERROR: can't open test file.\n"));
	603	}
	604
	605	wxPuts(wxEmptyString);
	606	}
	607
	608	static void TestTextFileRead()
	609	{
	610	wxPuts(_T("* wxTextFile read test *"));
	611
	612	wxTextFile file(_T("testdata.fc"));
	613	if ( file.Open() )
	614	{
	615	wxPrintf(_T("Number of lines: %u\n"), file.GetLineCount());
	616	wxPrintf(_T("Last line: '%s'\n"), file.GetLastLine().c_str());
	617
	618	wxString s;
	619
	620	wxPuts(_T("\nDumping the entire file:"));
	621	for ( s = file.GetFirstLine(); !file.Eof(); s = file.GetNextLine() )
	622	{
	623	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	624	}
	625	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	626
	627	wxPuts(_T("\nAnd now backwards:"));
	628	for ( s = file.GetLastLine();
	629	file.GetCurrentLine() != 0;
	630	s = file.GetPrevLine() )
	631	{
	632	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	633	}
	634	wxPrintf(_T("%6u: %s\n"), file.GetCurrentLine() + 1, s.c_str());
	635	}
	636	else
	637	{
	638	wxPrintf(_T("ERROR: can't open '%s'\n"), file.GetName());
	639	}
	640
	641	wxPuts(wxEmptyString);
	642	}
	643
	644	static void TestFileCopy()
	645	{
	646	wxPuts(_T("* Testing wxCopyFile *"));
	647
	648	static const wxChar *filename1 = _T("testdata.fc");
	649	static const wxChar *filename2 = _T("test2");
	650	if ( !wxCopyFile(filename1, filename2) )
	651	{
	652	wxPuts(_T("ERROR: failed to copy file"));
	653	}
	654	else
	655	{
	656	wxFFile f1(filename1, _T("rb")),
	657	f2(filename2, _T("rb"));
	658
	659	if ( !f1.IsOpened() \|\| !f2.IsOpened() )
	660	{
	661	wxPuts(_T("ERROR: failed to open file(s)"));
	662	}
	663	else
	664	{
	665	wxString s1, s2;
	666	if ( !f1.ReadAll(&s1) \|\| !f2.ReadAll(&s2) )
	667	{
	668	wxPuts(_T("ERROR: failed to read file(s)"));
	669	}
	670	else
	671	{
	672	if ( (s1.length() != s2.length()) \|\|
	673	(memcmp(s1.c_str(), s2.c_str(), s1.length()) != 0) )
	674	{
	675	wxPuts(_T("ERROR: copy error!"));
	676	}
	677	else
	678	{
	679	wxPuts(_T("File was copied ok."));
	680	}
	681	}
	682	}
	683	}
	684
	685	if ( !wxRemoveFile(filename2) )
	686	{
	687	wxPuts(_T("ERROR: failed to remove the file"));
	688	}
	689
	690	wxPuts(wxEmptyString);
	691	}
	692
	693	#endif // TEST_FILE
	694
	695	// ----------------------------------------------------------------------------
	696	// wxFileConfig
	697	// ----------------------------------------------------------------------------
	698
	699	#ifdef TEST_FILECONF
	700
	701	#include "wx/confbase.h"
	702	#include "wx/fileconf.h"
	703
	704	static const struct FileConfTestData
	705	{
	706	const wxChar *name; // value name
	707	const wxChar *value; // the value from the file
	708	} fcTestData[] =
	709	{
	710	{ _T("value1"), _T("one") },
	711	{ _T("value2"), _T("two") },
	712	{ _T("novalue"), _T("default") },
	713	};
	714
	715	static void TestFileConfRead()
	716	{
	717	wxPuts(_T("* testing wxFileConfig loading/reading *"));
	718
	719	wxFileConfig fileconf(_T("test"), wxEmptyString,
	720	_T("testdata.fc"), wxEmptyString,
	721	wxCONFIG_USE_RELATIVE_PATH);
	722
	723	// test simple reading
	724	wxPuts(_T("\nReading config file:"));
	725	wxString defValue(_T("default")), value;
	726	for ( size_t n = 0; n < WXSIZEOF(fcTestData); n++ )
	727	{
	728	const FileConfTestData& data = fcTestData[n];
	729	value = fileconf.Read(data.name, defValue);
	730	wxPrintf(_T("\t%s = %s "), data.name, value.c_str());
	731	if ( value == data.value )
	732	{
	733	wxPuts(_T("(ok)"));
	734	}
	735	else
	736	{
	737	wxPrintf(_T("(ERROR: should be %s)\n"), data.value);
	738	}
	739	}
	740
	741	// test enumerating the entries
	742	wxPuts(_T("\nEnumerating all root entries:"));
	743	long dummy;
	744	wxString name;
	745	bool cont = fileconf.GetFirstEntry(name, dummy);
	746	while ( cont )
	747	{
	748	wxPrintf(_T("\t%s = %s\n"),
	749	name.c_str(),
	750	fileconf.Read(name.c_str(), _T("ERROR")).c_str());
	751
	752	cont = fileconf.GetNextEntry(name, dummy);
	753	}
	754
	755	static const wxChar *testEntry = _T("TestEntry");
	756	wxPrintf(_T("\nTesting deletion of newly created \"Test\" entry: "));
	757	fileconf.Write(testEntry, _T("A value"));
	758	fileconf.DeleteEntry(testEntry);
	759	wxPrintf(fileconf.HasEntry(testEntry) ? _T("ERROR\n") : _T("ok\n"));
	760	}
	761
	762	#endif // TEST_FILECONF
	763
	764	// ----------------------------------------------------------------------------
	765	// wxFileName
	766	// ----------------------------------------------------------------------------
	767
	768	#ifdef TEST_FILENAME
	769
	770	#include "wx/filename.h"
	771
	772	#if 0
	773	static void DumpFileName(const wxChar *desc, const wxFileName& fn)
	774	{
	775	wxPuts(desc);
	776
	777	wxString full = fn.GetFullPath();
	778
	779	wxString vol, path, name, ext;
	780	wxFileName::SplitPath(full, &vol, &path, &name, &ext);
	781
	782	wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
	783	full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
	784
	785	wxFileName::SplitPath(full, &path, &name, &ext);
	786	wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
	787	path.c_str(), name.c_str(), ext.c_str());
	788
	789	wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
	790	wxPrintf(_T("with volume: \t'%s'\n"),
	791	fn.GetPath(wxPATH_GET_VOLUME).c_str());
	792	wxPrintf(_T("with separator:\t'%s'\n"),
	793	fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
	794	wxPrintf(_T("with both: \t'%s'\n"),
	795	fn.GetPath(wxPATH_GET_SEPARATOR \| wxPATH_GET_VOLUME).c_str());
	796
	797	wxPuts(_T("The directories in the path are:"));
	798	wxArrayString dirs = fn.GetDirs();
	799	size_t count = dirs.GetCount();
	800	for ( size_t n = 0; n < count; n++ )
	801	{
	802	wxPrintf(_T("\t%u: %s\n"), n, dirs[n].c_str());
	803	}
	804	}
	805	#endif
	806
	807	static struct FileNameInfo
	808	{
	809	const wxChar *fullname;
	810	const wxChar *volume;
	811	const wxChar *path;
	812	const wxChar *name;
	813	const wxChar *ext;
	814	bool isAbsolute;
	815	wxPathFormat format;
	816	} filenames[] =
	817	{
	818	// Unix file names
	819	{ _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), true, wxPATH_UNIX },
	820	{ _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), true, wxPATH_UNIX },
	821	{ _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), true, wxPATH_UNIX },
	822	{ _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), false, wxPATH_UNIX },
	823	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_UNIX },
	824	{ _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), true, wxPATH_UNIX },
	825	{ _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), true, wxPATH_UNIX },
	826	{ _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), false, wxPATH_UNIX },
	827	{ _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), true, wxPATH_UNIX },
	828
	829	// Windows file names
	830	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
	831	{ _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), false, wxPATH_DOS },
	832	{ _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
	833	{ _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	834	{ _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), true, wxPATH_DOS },
	835	{ _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	836	{ _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	837
	838	// wxFileName support for Mac file names is broken currently
	839	#if 0
	840	// Mac file names
	841	{ _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), true, wxPATH_MAC },
	842	{ _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), true, wxPATH_MAC },
	843	{ _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), true, wxPATH_MAC },
	844	{ _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), false, wxPATH_MAC },
	845	{ _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
	846	{ _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
	847	#endif // 0
	848
	849	// VMS file names
	850	{ _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), true, wxPATH_VMS },
	851	{ _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
	852	};
	853
	854	static void TestFileNameConstruction()
	855	{
	856	wxPuts(_T("* testing wxFileName construction *"));
	857
	858	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	859	{
	860	const FileNameInfo& fni = filenames[n];
	861
	862	wxFileName fn(fni.fullname, fni.format);
	863
	864	wxString fullname = fn.GetFullPath(fni.format);
	865	if ( fullname != fni.fullname )
	866	{
	867	wxPrintf(_T("ERROR: fullname should be '%s'\n"), fni.fullname);
	868	}
	869
	870	bool isAbsolute = fn.IsAbsolute(fni.format);
	871	wxPrintf(_T("'%s' is %s (%s)\n\t"),
	872	fullname.c_str(),
	873	isAbsolute ? "absolute" : "relative",
	874	isAbsolute == fni.isAbsolute ? "ok" : "ERROR");
	875
	876	if ( !fn.Normalize(wxPATH_NORM_ALL, wxEmptyString, fni.format) )
	877	{
	878	wxPuts(_T("ERROR (couldn't be normalized)"));
	879	}
	880	else
	881	{
	882	wxPrintf(_T("normalized: '%s'\n"), fn.GetFullPath(fni.format).c_str());
	883	}
	884	}
	885
	886	wxPuts(wxEmptyString);
	887	}
	888
	889	static void TestFileNameSplit()
	890	{
	891	wxPuts(_T("* testing wxFileName splitting *"));
	892
	893	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	894	{
	895	const FileNameInfo& fni = filenames[n];
	896	wxString volume, path, name, ext;
	897	wxFileName::SplitPath(fni.fullname,
	898	&volume, &path, &name, &ext, fni.format);
	899
	900	wxPrintf(_T("%s -> volume = '%s', path = '%s', name = '%s', ext = '%s'"),
	901	fni.fullname,
	902	volume.c_str(), path.c_str(), name.c_str(), ext.c_str());
	903
	904	if ( volume != fni.volume )
	905	wxPrintf(_T(" (ERROR: volume = '%s')"), fni.volume);
	906	if ( path != fni.path )
	907	wxPrintf(_T(" (ERROR: path = '%s')"), fni.path);
	908	if ( name != fni.name )
	909	wxPrintf(_T(" (ERROR: name = '%s')"), fni.name);
	910	if ( ext != fni.ext )
	911	wxPrintf(_T(" (ERROR: ext = '%s')"), fni.ext);
	912
	913	wxPuts(wxEmptyString);
	914	}
	915	}
	916
	917	static void TestFileNameTemp()
	918	{
	919	wxPuts(_T("* testing wxFileName temp file creation *"));
	920
	921	static const wxChar *tmpprefixes[] =
	922	{
	923	_T(""),
	924	_T("foo"),
	925	_T(".."),
	926	_T("../bar"),
	927	#ifdef __UNIX__
	928	_T("/tmp/foo"),
	929	_T("/tmp/foo/bar"), // this one must be an error
	930	#endif // __UNIX__
	931	};
	932
	933	for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
	934	{
	935	wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
	936	if ( path.empty() )
	937	{
	938	// "error" is not in upper case because it may be ok
	939	wxPrintf(_T("Prefix '%s'\t-> error\n"), tmpprefixes[n]);
	940	}
	941	else
	942	{
	943	wxPrintf(_T("Prefix '%s'\t-> temp file '%s'\n"),
	944	tmpprefixes[n], path.c_str());
	945
	946	if ( !wxRemoveFile(path) )
	947	{
	948	wxLogWarning(_T("Failed to remove temp file '%s'"),
	949	path.c_str());
	950	}
	951	}
	952	}
	953	}
	954
	955	static void TestFileNameMakeRelative()
	956	{
	957	wxPuts(_T("* testing wxFileName::MakeRelativeTo() *"));
	958
	959	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	960	{
	961	const FileNameInfo& fni = filenames[n];
	962
	963	wxFileName fn(fni.fullname, fni.format);
	964
	965	// choose the base dir of the same format
	966	wxString base;
	967	switch ( fni.format )
	968	{
	969	case wxPATH_UNIX:
	970	base = _T("/usr/bin/");
	971	break;
	972
	973	case wxPATH_DOS:
	974	base = _T("c:\\");
	975	break;
	976
	977	case wxPATH_MAC:
	978	case wxPATH_VMS:
	979	// TODO: I don't know how this is supposed to work there
	980	continue;
	981
	982	case wxPATH_NATIVE: // make gcc happy
	983	default:
	984	wxFAIL_MSG( _T("unexpected path format") );
	985	}
	986
	987	wxPrintf(_T("'%s' relative to '%s': "),
	988	fn.GetFullPath(fni.format).c_str(), base.c_str());
	989
	990	if ( !fn.MakeRelativeTo(base, fni.format) )
	991	{
	992	wxPuts(_T("unchanged"));
	993	}
	994	else
	995	{
	996	wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
	997	}
	998	}
	999	}
	1000
	1001	static void TestFileNameMakeAbsolute()
	1002	{
	1003	wxPuts(_T("* testing wxFileName::MakeAbsolute() *"));
	1004
	1005	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	1006	{
	1007	const FileNameInfo& fni = filenames[n];
	1008	wxFileName fn(fni.fullname, fni.format);
	1009
	1010	wxPrintf(_T("'%s' absolutized: "),
	1011	fn.GetFullPath(fni.format).c_str());
	1012	fn.MakeAbsolute();
	1013	wxPrintf(_T("'%s'\n"), fn.GetFullPath(fni.format).c_str());
	1014	}
	1015
	1016	wxPuts(wxEmptyString);
	1017	}
	1018
	1019	static void TestFileNameDirManip()
	1020	{
	1021	// TODO: test AppendDir(), RemoveDir(), ...
	1022	}
	1023
	1024	static void TestFileNameComparison()
	1025	{
	1026	// TODO!
	1027	}
	1028
	1029	static void TestFileNameOperations()
	1030	{
	1031	// TODO!
	1032	}
	1033
	1034	static void TestFileNameCwd()
	1035	{
	1036	// TODO!
	1037	}
	1038
	1039	#endif // TEST_FILENAME
	1040
	1041	// ----------------------------------------------------------------------------
	1042	// wxFileName time functions
	1043	// ----------------------------------------------------------------------------
	1044
	1045	#ifdef TEST_FILETIME
	1046
	1047	#include <wx/filename.h>
	1048	#include <wx/datetime.h>
	1049
	1050	static void TestFileGetTimes()
	1051	{
	1052	wxFileName fn(_T("testdata.fc"));
	1053
	1054	wxDateTime dtAccess, dtMod, dtCreate;
	1055	if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
	1056	{
	1057	wxPrintf(_T("ERROR: GetTimes() failed.\n"));
	1058	}
	1059	else
	1060	{
	1061	static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
	1062
	1063	wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
	1064	wxPrintf(_T("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
	1065	wxPrintf(_T("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
	1066	wxPrintf(_T("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
	1067	}
	1068	}
	1069
	1070	#if 0
	1071	static void TestFileSetTimes()
	1072	{
	1073	wxFileName fn(_T("testdata.fc"));
	1074
	1075	if ( !fn.Touch() )
	1076	{
	1077	wxPrintf(_T("ERROR: Touch() failed.\n"));
	1078	}
	1079	}
	1080	#endif
	1081
	1082	#endif // TEST_FILETIME
	1083
	1084	// ----------------------------------------------------------------------------
	1085	// wxHashMap
	1086	// ----------------------------------------------------------------------------
	1087
	1088	#ifdef TEST_HASHMAP
	1089
	1090	#include "wx/hashmap.h"
	1091
	1092	// test compilation of basic map types
	1093	WX_DECLARE_HASH_MAP( int, int, wxPointerHash, wxPointerEqual, myPtrHashMap );
	1094	WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
	1095	WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
	1096	myUnsignedHashMap );
	1097	WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
	1098	myTestHashMap1 );
	1099	WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
	1100	myTestHashMap2 );
	1101	WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
	1102	myTestHashMap3 );
	1103	WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
	1104	myTestHashMap4 );
	1105
	1106	// same as:
	1107	// WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
	1108	// myStringHashMap );
	1109	WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
	1110
	1111	typedef myStringHashMap::iterator Itor;
	1112
	1113	static void TestHashMap()
	1114	{
	1115	wxPuts(_T("* Testing wxHashMap *\n"));
	1116	myStringHashMap sh(0); // as small as possible
	1117	wxString buf;
	1118	size_t i;
	1119	const size_t count = 10000;
	1120
	1121	// init with some data
	1122	for( i = 0; i < count; ++i )
	1123	{
	1124	buf.Printf(wxT("%d"), i );
	1125	sh[buf] = wxT("A") + buf + wxT("C");
	1126	}
	1127
	1128	// test that insertion worked
	1129	if( sh.size() != count )
	1130	{
	1131	wxPrintf(_T("* ERROR: %u ELEMENTS, SHOULD BE %u *\n"), sh.size(), count);
	1132	}
	1133
	1134	for( i = 0; i < count; ++i )
	1135	{
	1136	buf.Printf(wxT("%d"), i );
	1137	if( sh[buf] != wxT("A") + buf + wxT("C") )
	1138	{
	1139	wxPrintf(_T("* ERROR INSERTION BROKEN! STOPPING NOW! *\n"));
	1140	return;
	1141	}
	1142	}
	1143
	1144	// check that iterators work
	1145	Itor it;
	1146	for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
	1147	{
	1148	if( i == count )
	1149	{
	1150	wxPrintf(_T("* ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! *\n"));
	1151	return;
	1152	}
	1153
	1154	if( it->second != sh[it->first] )
	1155	{
	1156	wxPrintf(_T("* ERROR ITERATORS BROKEN! STOPPING NOW! *\n"));
	1157	return;
	1158	}
	1159	}
	1160
	1161	if( sh.size() != i )
	1162	{
	1163	wxPrintf(_T("* ERROR: %u ELEMENTS ITERATED, SHOULD BE %u *\n"), i, count);
	1164	}
	1165
	1166	// test copy ctor, assignment operator
	1167	myStringHashMap h1( sh ), h2( 0 );
	1168	h2 = sh;
	1169
	1170	for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
	1171	{
	1172	if( h1[it->first] != it->second )
	1173	{
	1174	wxPrintf(_T("* ERROR: COPY CTOR BROKEN %s *\n"), it->first.c_str());
	1175	}
	1176
	1177	if( h2[it->first] != it->second )
	1178	{
	1179	wxPrintf(_T("* ERROR: OPERATOR= BROKEN %s *\n"), it->first.c_str());
	1180	}
	1181	}
	1182
	1183	// other tests
	1184	for( i = 0; i < count; ++i )
	1185	{
	1186	buf.Printf(wxT("%d"), i );
	1187	size_t sz = sh.size();
	1188
	1189	// test find() and erase(it)
	1190	if( i < 100 )
	1191	{
	1192	it = sh.find( buf );
	1193	if( it != sh.end() )
	1194	{
	1195	sh.erase( it );
	1196
	1197	if( sh.find( buf ) != sh.end() )
	1198	{
	1199	wxPrintf(_T("* ERROR: FOUND DELETED ELEMENT %u *\n"), i);
	1200	}
	1201	}
	1202	else
	1203	wxPrintf(_T("* ERROR: CANT FIND ELEMENT %u *\n"), i);
	1204	}
	1205	else
	1206	// test erase(key)
	1207	{
	1208	size_t c = sh.erase( buf );
	1209	if( c != 1 )
	1210	wxPrintf(_T("* ERROR: SHOULD RETURN 1 *\n"));
	1211
	1212	if( sh.find( buf ) != sh.end() )
	1213	{
	1214	wxPrintf(_T("* ERROR: FOUND DELETED ELEMENT %u *\n"), i);
	1215	}
	1216	}
	1217
	1218	// count should decrease
	1219	if( sh.size() != sz - 1 )
	1220	{
	1221	wxPrintf(_T("* ERROR: COUNT DID NOT DECREASE *\n"));
	1222	}
	1223	}
	1224
	1225	wxPrintf(_T("* Finished testing wxHashMap *\n"));
	1226	}
	1227
	1228	#endif // TEST_HASHMAP
	1229
	1230	// ----------------------------------------------------------------------------
	1231	// wxHashSet
	1232	// ----------------------------------------------------------------------------
	1233
	1234	#ifdef TEST_HASHSET
	1235
	1236	#include "wx/hashset.h"
	1237
	1238	// test compilation of basic map types
	1239	WX_DECLARE_HASH_SET( int*, wxPointerHash, wxPointerEqual, myPtrHashSet );
	1240	WX_DECLARE_HASH_SET( long, wxIntegerHash, wxIntegerEqual, myLongHashSet );
	1241	WX_DECLARE_HASH_SET( unsigned long, wxIntegerHash, wxIntegerEqual,
	1242	myUnsignedHashSet );
	1243	WX_DECLARE_HASH_SET( unsigned int, wxIntegerHash, wxIntegerEqual,
	1244	myTestHashSet1 );
	1245	WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual,
	1246	myTestHashSet2 );
	1247	WX_DECLARE_HASH_SET( short, wxIntegerHash, wxIntegerEqual,
	1248	myTestHashSet3 );
	1249	WX_DECLARE_HASH_SET( unsigned short, wxIntegerHash, wxIntegerEqual,
	1250	myTestHashSet4 );
	1251	WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual,
	1252	myTestHashSet5 );
	1253
	1254	struct MyStruct
	1255	{
	1256	int* ptr;
	1257	wxString str;
	1258	};
	1259
	1260	class MyHash
	1261	{
	1262	public:
	1263	unsigned long operator()(const MyStruct& s) const
	1264	{ return m_dummy(s.ptr); }
	1265	MyHash& operator=(const MyHash&) { return *this; }
	1266	private:
	1267	wxPointerHash m_dummy;
	1268	};
	1269
	1270	class MyEqual
	1271	{
	1272	public:
	1273	bool operator()(const MyStruct& s1, const MyStruct& s2) const
	1274	{ return s1.ptr == s2.ptr; }
	1275	MyEqual& operator=(const MyEqual&) { return *this; }
	1276	};
	1277
	1278	WX_DECLARE_HASH_SET( MyStruct, MyHash, MyEqual, mySet );
	1279
	1280	typedef myTestHashSet5 wxStringHashSet;
	1281
	1282	static void TestHashSet()
	1283	{
	1284	wxPrintf(_T("* Testing wxHashSet *\n"));
	1285
	1286	wxStringHashSet set1;
	1287
	1288	set1.insert( _T("abc") );
	1289	set1.insert( _T("bbc") );
	1290	set1.insert( _T("cbc") );
	1291	set1.insert( _T("abc") );
	1292
	1293	if( set1.size() != 3 )
	1294	wxPrintf(_T("* ERROR IN INSERT *\n"));
	1295
	1296	mySet set2;
	1297	int dummy;
	1298	MyStruct tmp;
	1299
	1300	tmp.ptr = &dummy; tmp.str = _T("ABC");
	1301	set2.insert( tmp );
	1302	tmp.ptr = &dummy + 1;
	1303	set2.insert( tmp );
	1304	tmp.ptr = &dummy; tmp.str = _T("CDE");
	1305	set2.insert( tmp );
	1306
	1307	if( set2.size() != 2 )
	1308	wxPrintf(_T("* ERROR IN INSERT - 2 *\n"));
	1309
	1310	mySet::iterator it = set2.find( tmp );
	1311
	1312	if( it == set2.end() )
	1313	wxPrintf(_T("* ERROR IN FIND - 1 *\n"));
	1314	if( it->ptr != &dummy )
	1315	wxPrintf(_T("* ERROR IN FIND - 2 *\n"));
	1316	if( it->str != _T("ABC") )
	1317	wxPrintf(_T("* ERROR IN INSERT - 3 *\n"));
	1318
	1319	wxPrintf(_T("* Finished testing wxHashSet *\n"));
	1320	}
	1321
	1322	#endif // TEST_HASHSET
	1323
	1324	// ----------------------------------------------------------------------------
	1325	// wxList
	1326	// ----------------------------------------------------------------------------
	1327
	1328	#ifdef TEST_LIST
	1329
	1330	#include "wx/list.h"
	1331
	1332	WX_DECLARE_LIST(Bar, wxListBars);
	1333	#include "wx/listimpl.cpp"
	1334	WX_DEFINE_LIST(wxListBars);
	1335
	1336	WX_DECLARE_LIST(int, wxListInt);
	1337	WX_DEFINE_LIST(wxListInt);
	1338
	1339	static void TestList()
	1340	{
	1341	wxPuts(_T("* Testing wxList operations *\n"));
	1342	{
	1343	wxListInt list1;
	1344	int dummy[5];
	1345	int i;
	1346
	1347	for ( i = 0; i < 5; ++i )
	1348	list1.Append(dummy + i);
	1349
	1350	if ( list1.GetCount() != 5 )
	1351	wxPuts(_T("Wrong number of items in list\n"));
	1352
	1353	if ( list1.Item(3)->GetData() != dummy + 3 )
	1354	wxPuts(_T("Error in Item()\n"));
	1355
	1356	if ( !list1.Find(dummy + 4) )
	1357	wxPuts(_T("Error in Find()\n"));
	1358
	1359	wxListInt::compatibility_iterator node = list1.GetFirst();
	1360	i = 0;
	1361
	1362	while (node)
	1363	{
	1364	if ( node->GetData() != dummy + i )
	1365	wxPuts(_T("Error in compatibility_iterator\n"));
	1366	node = node->GetNext();
	1367	++i;
	1368	}
	1369
	1370	if ( size_t(i) != list1.GetCount() )
	1371	wxPuts(_T("Error in compatibility_iterator\n"));
	1372
	1373	list1.Insert(dummy + 0);
	1374	list1.Insert(1, dummy + 1);
	1375	list1.Insert(list1.GetFirst()->GetNext()->GetNext(), dummy + 2);
	1376
	1377	node = list1.GetFirst();
	1378	i = 0;
	1379
	1380	while (i < 3)
	1381	{
	1382	int* t = node->GetData();
	1383	if ( t != dummy + i )
	1384	wxPuts(_T("Error in Insert\n"));
	1385	node = node->GetNext();
	1386	++i;
	1387	}
	1388	}
	1389
	1390	wxPuts(_T("* Testing wxList operations finished *\n"));
	1391
	1392	wxPuts(_T("* Testing std::list operations *\n"));
	1393
	1394	{
	1395	wxListInt list1;
	1396	wxListInt::iterator it, en;
	1397	wxListInt::reverse_iterator rit, ren;
	1398	int i;
	1399	for ( i = 0; i < 5; ++i )
	1400	list1.push_back(i + &i);
	1401
	1402	for ( it = list1.begin(), en = list1.end(), i = 0;
	1403	it != en; ++it, ++i )
	1404	if ( *it != i + &i )
	1405	wxPuts(_T("Error in iterator\n"));
	1406
	1407	for ( rit = list1.rbegin(), ren = list1.rend(), i = 4;
	1408	rit != ren; ++rit, --i )
	1409	if ( *rit != i + &i )
	1410	wxPuts(_T("Error in reverse_iterator\n"));
	1411
	1412	if ( list1.rbegin() != --list1.end() \|\|
	1413	list1.begin() != --list1.rend() )
	1414	wxPuts(_T("Error in iterator/reverse_iterator\n"));
	1415	if ( list1.begin() != --++list1.begin() \|\|
	1416	list1.rbegin() != --++list1.rbegin() )
	1417	wxPuts(_T("Error in iterator/reverse_iterator\n"));
	1418
	1419	if ( list1.front() != &i \|\| list1.back() != &i + 4 )
	1420	wxPuts(_T("Error in front()/back()\n"));
	1421
	1422	list1.erase(list1.begin());
	1423	list1.erase(--list1.end());
	1424
	1425	for ( it = list1.begin(), en = list1.end(), i = 1;
	1426	it != en; ++it, ++i )
	1427	if ( *it != i + &i )
	1428	wxPuts(_T("Error in erase()\n"));
	1429	}
	1430
	1431	wxPuts(_T("* Testing std::list operations finished *\n"));
	1432	}
	1433
	1434	static void TestListCtor()
	1435	{
	1436	wxPuts(_T("* Testing wxList construction *\n"));
	1437
	1438	{
	1439	wxListBars list1;
	1440	list1.Append(new Bar(_T("first")));
	1441	list1.Append(new Bar(_T("second")));
	1442
	1443	wxPrintf(_T("After 1st list creation: %u objects in the list, %u objects total.\n"),
	1444	list1.GetCount(), Bar::GetNumber());
	1445
	1446	wxListBars list2;
	1447	list2 = list1;
	1448
	1449	wxPrintf(_T("After 2nd list creation: %u and %u objects in the lists, %u objects total.\n"),
	1450	list1.GetCount(), list2.GetCount(), Bar::GetNumber());
	1451
	1452	#if !wxUSE_STL
	1453	list1.DeleteContents(true);
	1454	#else
	1455	WX_CLEAR_LIST(wxListBars, list1);
	1456	#endif
	1457	}
	1458
	1459	wxPrintf(_T("After list destruction: %u objects left.\n"), Bar::GetNumber());
	1460	}
	1461
	1462	#endif // TEST_LIST
	1463
	1464	// ----------------------------------------------------------------------------
	1465	// wxLocale
	1466	// ----------------------------------------------------------------------------
	1467
	1468	#ifdef TEST_LOCALE
	1469
	1470	#include "wx/intl.h"
	1471	#include "wx/utils.h" // for wxSetEnv
	1472
	1473	static wxLocale gs_localeDefault(wxLANGUAGE_ENGLISH);
	1474
	1475	// find the name of the language from its value
	1476	static const wxChar *GetLangName(int lang)
	1477	{
	1478	static const wxChar *languageNames[] =
	1479	{
	1480	_T("DEFAULT"),
	1481	_T("UNKNOWN"),
	1482	_T("ABKHAZIAN"),
	1483	_T("AFAR"),
	1484	_T("AFRIKAANS"),
	1485	_T("ALBANIAN"),
	1486	_T("AMHARIC"),
	1487	_T("ARABIC"),
	1488	_T("ARABIC_ALGERIA"),
	1489	_T("ARABIC_BAHRAIN"),
	1490	_T("ARABIC_EGYPT"),
	1491	_T("ARABIC_IRAQ"),
	1492	_T("ARABIC_JORDAN"),
	1493	_T("ARABIC_KUWAIT"),
	1494	_T("ARABIC_LEBANON"),
	1495	_T("ARABIC_LIBYA"),
	1496	_T("ARABIC_MOROCCO"),
	1497	_T("ARABIC_OMAN"),
	1498	_T("ARABIC_QATAR"),
	1499	_T("ARABIC_SAUDI_ARABIA"),
	1500	_T("ARABIC_SUDAN"),
	1501	_T("ARABIC_SYRIA"),
	1502	_T("ARABIC_TUNISIA"),
	1503	_T("ARABIC_UAE"),
	1504	_T("ARABIC_YEMEN"),
	1505	_T("ARMENIAN"),
	1506	_T("ASSAMESE"),
	1507	_T("AYMARA"),
	1508	_T("AZERI"),
	1509	_T("AZERI_CYRILLIC"),
	1510	_T("AZERI_LATIN"),
	1511	_T("BASHKIR"),
	1512	_T("BASQUE"),
	1513	_T("BELARUSIAN"),
	1514	_T("BENGALI"),
	1515	_T("BHUTANI"),
	1516	_T("BIHARI"),
	1517	_T("BISLAMA"),
	1518	_T("BRETON"),
	1519	_T("BULGARIAN"),
	1520	_T("BURMESE"),
	1521	_T("CAMBODIAN"),
	1522	_T("CATALAN"),
	1523	_T("CHINESE"),
	1524	_T("CHINESE_SIMPLIFIED"),
	1525	_T("CHINESE_TRADITIONAL"),
	1526	_T("CHINESE_HONGKONG"),
	1527	_T("CHINESE_MACAU"),
	1528	_T("CHINESE_SINGAPORE"),
	1529	_T("CHINESE_TAIWAN"),
	1530	_T("CORSICAN"),
	1531	_T("CROATIAN"),
	1532	_T("CZECH"),
	1533	_T("DANISH"),
	1534	_T("DUTCH"),
	1535	_T("DUTCH_BELGIAN"),
	1536	_T("ENGLISH"),
	1537	_T("ENGLISH_UK"),
	1538	_T("ENGLISH_US"),
	1539	_T("ENGLISH_AUSTRALIA"),
	1540	_T("ENGLISH_BELIZE"),
	1541	_T("ENGLISH_BOTSWANA"),
	1542	_T("ENGLISH_CANADA"),
	1543	_T("ENGLISH_CARIBBEAN"),
	1544	_T("ENGLISH_DENMARK"),
	1545	_T("ENGLISH_EIRE"),
	1546	_T("ENGLISH_JAMAICA"),
	1547	_T("ENGLISH_NEW_ZEALAND"),
	1548	_T("ENGLISH_PHILIPPINES"),
	1549	_T("ENGLISH_SOUTH_AFRICA"),
	1550	_T("ENGLISH_TRINIDAD"),
	1551	_T("ENGLISH_ZIMBABWE"),
	1552	_T("ESPERANTO"),
	1553	_T("ESTONIAN"),
	1554	_T("FAEROESE"),
	1555	_T("FARSI"),
	1556	_T("FIJI"),
	1557	_T("FINNISH"),
	1558	_T("FRENCH"),
	1559	_T("FRENCH_BELGIAN"),
	1560	_T("FRENCH_CANADIAN"),
	1561	_T("FRENCH_LUXEMBOURG"),
	1562	_T("FRENCH_MONACO"),
	1563	_T("FRENCH_SWISS"),
	1564	_T("FRISIAN"),
	1565	_T("GALICIAN"),
	1566	_T("GEORGIAN"),
	1567	_T("GERMAN"),
	1568	_T("GERMAN_AUSTRIAN"),
	1569	_T("GERMAN_BELGIUM"),
	1570	_T("GERMAN_LIECHTENSTEIN"),
	1571	_T("GERMAN_LUXEMBOURG"),
	1572	_T("GERMAN_SWISS"),
	1573	_T("GREEK"),
	1574	_T("GREENLANDIC"),
	1575	_T("GUARANI"),
	1576	_T("GUJARATI"),
	1577	_T("HAUSA"),
	1578	_T("HEBREW"),
	1579	_T("HINDI"),
	1580	_T("HUNGARIAN"),
	1581	_T("ICELANDIC"),
	1582	_T("INDONESIAN"),
	1583	_T("INTERLINGUA"),
	1584	_T("INTERLINGUE"),
	1585	_T("INUKTITUT"),
	1586	_T("INUPIAK"),
	1587	_T("IRISH"),
	1588	_T("ITALIAN"),
	1589	_T("ITALIAN_SWISS"),
	1590	_T("JAPANESE"),
	1591	_T("JAVANESE"),
	1592	_T("KANNADA"),
	1593	_T("KASHMIRI"),
	1594	_T("KASHMIRI_INDIA"),
	1595	_T("KAZAKH"),
	1596	_T("KERNEWEK"),
	1597	_T("KINYARWANDA"),
	1598	_T("KIRGHIZ"),
	1599	_T("KIRUNDI"),
	1600	_T("KONKANI"),
	1601	_T("KOREAN"),
	1602	_T("KURDISH"),
	1603	_T("LAOTHIAN"),
	1604	_T("LATIN"),
	1605	_T("LATVIAN"),
	1606	_T("LINGALA"),
	1607	_T("LITHUANIAN"),
	1608	_T("MACEDONIAN"),
	1609	_T("MALAGASY"),
	1610	_T("MALAY"),
	1611	_T("MALAYALAM"),
	1612	_T("MALAY_BRUNEI_DARUSSALAM"),
	1613	_T("MALAY_MALAYSIA"),
	1614	_T("MALTESE"),
	1615	_T("MANIPURI"),
	1616	_T("MAORI"),
	1617	_T("MARATHI"),
	1618	_T("MOLDAVIAN"),
	1619	_T("MONGOLIAN"),
	1620	_T("NAURU"),
	1621	_T("NEPALI"),
	1622	_T("NEPALI_INDIA"),
	1623	_T("NORWEGIAN_BOKMAL"),
	1624	_T("NORWEGIAN_NYNORSK"),
	1625	_T("OCCITAN"),
	1626	_T("ORIYA"),
	1627	_T("OROMO"),
	1628	_T("PASHTO"),
	1629	_T("POLISH"),
	1630	_T("PORTUGUESE"),
	1631	_T("PORTUGUESE_BRAZILIAN"),
	1632	_T("PUNJABI"),
	1633	_T("QUECHUA"),
	1634	_T("RHAETO_ROMANCE"),
	1635	_T("ROMANIAN"),
	1636	_T("RUSSIAN"),
	1637	_T("RUSSIAN_UKRAINE"),
	1638	_T("SAMOAN"),
	1639	_T("SANGHO"),
	1640	_T("SANSKRIT"),
	1641	_T("SCOTS_GAELIC"),
	1642	_T("SERBIAN"),
	1643	_T("SERBIAN_CYRILLIC"),
	1644	_T("SERBIAN_LATIN"),
	1645	_T("SERBO_CROATIAN"),
	1646	_T("SESOTHO"),
	1647	_T("SETSWANA"),
	1648	_T("SHONA"),
	1649	_T("SINDHI"),
	1650	_T("SINHALESE"),
	1651	_T("SISWATI"),
	1652	_T("SLOVAK"),
	1653	_T("SLOVENIAN"),
	1654	_T("SOMALI"),
	1655	_T("SPANISH"),
	1656	_T("SPANISH_ARGENTINA"),
	1657	_T("SPANISH_BOLIVIA"),
	1658	_T("SPANISH_CHILE"),
	1659	_T("SPANISH_COLOMBIA"),
	1660	_T("SPANISH_COSTA_RICA"),
	1661	_T("SPANISH_DOMINICAN_REPUBLIC"),
	1662	_T("SPANISH_ECUADOR"),
	1663	_T("SPANISH_EL_SALVADOR"),
	1664	_T("SPANISH_GUATEMALA"),
	1665	_T("SPANISH_HONDURAS"),
	1666	_T("SPANISH_MEXICAN"),
	1667	_T("SPANISH_MODERN"),
	1668	_T("SPANISH_NICARAGUA"),
	1669	_T("SPANISH_PANAMA"),
	1670	_T("SPANISH_PARAGUAY"),
	1671	_T("SPANISH_PERU"),
	1672	_T("SPANISH_PUERTO_RICO"),
	1673	_T("SPANISH_URUGUAY"),
	1674	_T("SPANISH_US"),
	1675	_T("SPANISH_VENEZUELA"),
	1676	_T("SUNDANESE"),
	1677	_T("SWAHILI"),
	1678	_T("SWEDISH"),
	1679	_T("SWEDISH_FINLAND"),
	1680	_T("TAGALOG"),
	1681	_T("TAJIK"),
	1682	_T("TAMIL"),
	1683	_T("TATAR"),
	1684	_T("TELUGU"),
	1685	_T("THAI"),
	1686	_T("TIBETAN"),
	1687	_T("TIGRINYA"),
	1688	_T("TONGA"),
	1689	_T("TSONGA"),
	1690	_T("TURKISH"),
	1691	_T("TURKMEN"),
	1692	_T("TWI"),
	1693	_T("UIGHUR"),
	1694	_T("UKRAINIAN"),
	1695	_T("URDU"),
	1696	_T("URDU_INDIA"),
	1697	_T("URDU_PAKISTAN"),
	1698	_T("UZBEK"),
	1699	_T("UZBEK_CYRILLIC"),
	1700	_T("UZBEK_LATIN"),
	1701	_T("VIETNAMESE"),
	1702	_T("VOLAPUK"),
	1703	_T("WELSH"),
	1704	_T("WOLOF"),
	1705	_T("XHOSA"),
	1706	_T("YIDDISH"),
	1707	_T("YORUBA"),
	1708	_T("ZHUANG"),
	1709	_T("ZULU"),
	1710	};
	1711
	1712	if ( (size_t)lang < WXSIZEOF(languageNames) )
	1713	return languageNames[lang];
	1714	else
	1715	return _T("INVALID");
	1716	}
	1717
	1718	static void TestDefaultLang()
	1719	{
	1720	wxPuts(_T("* Testing wxLocale::GetSystemLanguage *"));
	1721
	1722	static const wxChar *langStrings[] =
	1723	{
	1724	NULL, // system default
	1725	_T("C"),
	1726	_T("fr"),
	1727	_T("fr_FR"),
	1728	_T("en"),
	1729	_T("en_GB"),
	1730	_T("en_US"),
	1731	_T("de_DE.iso88591"),
	1732	_T("german"),
	1733	_T("?"), // invalid lang spec
	1734	_T("klingonese"), // I bet on some systems it does exist...
	1735	};
	1736
	1737	wxPrintf(_T("The default system encoding is %s (%d)\n"),
	1738	wxLocale::GetSystemEncodingName().c_str(),
	1739	wxLocale::GetSystemEncoding());
	1740
	1741	for ( size_t n = 0; n < WXSIZEOF(langStrings); n++ )
	1742	{
	1743	const wxChar *langStr = langStrings[n];
	1744	if ( langStr )
	1745	{
	1746	// FIXME: this doesn't do anything at all under Windows, we need
	1747	// to create a new wxLocale!
	1748	wxSetEnv(_T("LC_ALL"), langStr);
	1749	}
	1750
	1751	int lang = gs_localeDefault.GetSystemLanguage();
	1752	wxPrintf(_T("Locale for '%s' is %s.\n"),
	1753	langStr ? langStr : _T("system default"), GetLangName(lang));
	1754	}
	1755	}
	1756
	1757	#endif // TEST_LOCALE
	1758
	1759	// ----------------------------------------------------------------------------
	1760	// MIME types
	1761	// ----------------------------------------------------------------------------
	1762
	1763	#ifdef TEST_MIME
	1764
	1765	#include "wx/mimetype.h"
	1766
	1767	static void TestMimeEnum()
	1768	{
	1769	wxPuts(_T("* Testing wxMimeTypesManager::EnumAllFileTypes() *\n"));
	1770
	1771	wxArrayString mimetypes;
	1772
	1773	size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
	1774
	1775	wxPrintf(_T("* All %u known filetypes: *\n"), count);
	1776
	1777	wxArrayString exts;
	1778	wxString desc;
	1779
	1780	for ( size_t n = 0; n < count; n++ )
	1781	{
	1782	wxFileType *filetype =
	1783	wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
	1784	if ( !filetype )
	1785	{
	1786	wxPrintf(_T("nothing known about the filetype '%s'!\n"),
	1787	mimetypes[n].c_str());
	1788	continue;
	1789	}
	1790
	1791	filetype->GetDescription(&desc);
	1792	filetype->GetExtensions(exts);
	1793
	1794	filetype->GetIcon(NULL);
	1795
	1796	wxString extsAll;
	1797	for ( size_t e = 0; e < exts.GetCount(); e++ )
	1798	{
	1799	if ( e > 0 )
	1800	extsAll << _T(", ");
	1801	extsAll += exts[e];
	1802	}
	1803
	1804	wxPrintf(_T("\t%s: %s (%s)\n"),
	1805	mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
	1806	}
	1807
	1808	wxPuts(wxEmptyString);
	1809	}
	1810
	1811	static void TestMimeOverride()
	1812	{
	1813	wxPuts(_T("* Testing wxMimeTypesManager additional files loading *\n"));
	1814
	1815	static const wxChar *mailcap = _T("/tmp/mailcap");
	1816	static const wxChar *mimetypes = _T("/tmp/mime.types");
	1817
	1818	if ( wxFile::Exists(mailcap) )
	1819	wxPrintf(_T("Loading mailcap from '%s': %s\n"),
	1820	mailcap,
	1821	wxTheMimeTypesManager->ReadMailcap(mailcap) ? _T("ok") : _T("ERROR"));
	1822	else
	1823	wxPrintf(_T("WARN: mailcap file '%s' doesn't exist, not loaded.\n"),
	1824	mailcap);
	1825
	1826	if ( wxFile::Exists(mimetypes) )
	1827	wxPrintf(_T("Loading mime.types from '%s': %s\n"),
	1828	mimetypes,
	1829	wxTheMimeTypesManager->ReadMimeTypes(mimetypes) ? _T("ok") : _T("ERROR"));
	1830	else
	1831	wxPrintf(_T("WARN: mime.types file '%s' doesn't exist, not loaded.\n"),
	1832	mimetypes);
	1833
	1834	wxPuts(wxEmptyString);
	1835	}
	1836
	1837	static void TestMimeFilename()
	1838	{
	1839	wxPuts(_T("* Testing MIME type from filename query *\n"));
	1840
	1841	static const wxChar *filenames[] =
	1842	{
	1843	_T("readme.txt"),
	1844	_T("document.pdf"),
	1845	_T("image.gif"),
	1846	_T("picture.jpeg"),
	1847	};
	1848
	1849	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	1850	{
	1851	const wxString fname = filenames[n];
	1852	wxString ext = fname.AfterLast(_T('.'));
	1853	wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
	1854	if ( !ft )
	1855	{
	1856	wxPrintf(_T("WARNING: extension '%s' is unknown.\n"), ext.c_str());
	1857	}
	1858	else
	1859	{
	1860	wxString desc;
	1861	if ( !ft->GetDescription(&desc) )
	1862	desc = _T("<no description>");
	1863
	1864	wxString cmd;
	1865	if ( !ft->GetOpenCommand(&cmd,
	1866	wxFileType::MessageParameters(fname, wxEmptyString)) )
	1867	cmd = _T("<no command available>");
	1868	else
	1869	cmd = wxString(_T('"')) + cmd + _T('"');
	1870
	1871	wxPrintf(_T("To open %s (%s) do %s.\n"),
	1872	fname.c_str(), desc.c_str(), cmd.c_str());
	1873
	1874	delete ft;
	1875	}
	1876	}
	1877
	1878	wxPuts(wxEmptyString);
	1879	}
	1880
	1881	static void TestMimeAssociate()
	1882	{
	1883	wxPuts(_T("* Testing creation of filetype association *\n"));
	1884
	1885	wxFileTypeInfo ftInfo(
	1886	_T("application/x-xyz"),
	1887	_T("xyzview '%s'"), // open cmd
	1888	_T(""), // print cmd
	1889	_T("XYZ File"), // description
	1890	_T(".xyz"), // extensions
	1891	NULL // end of extensions
	1892	);
	1893	ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
	1894
	1895	wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
	1896	if ( !ft )
	1897	{
	1898	wxPuts(_T("ERROR: failed to create association!"));
	1899	}
	1900	else
	1901	{
	1902	// TODO: read it back
	1903	delete ft;
	1904	}
	1905
	1906	wxPuts(wxEmptyString);
	1907	}
	1908
	1909	#endif // TEST_MIME
	1910
	1911	// ----------------------------------------------------------------------------
	1912	// misc information functions
	1913	// ----------------------------------------------------------------------------
	1914
	1915	#ifdef TEST_INFO_FUNCTIONS
	1916
	1917	#include "wx/utils.h"
	1918
	1919	static void TestDiskInfo()
	1920	{
	1921	wxPuts(_T("* Testing wxGetDiskSpace() *"));
	1922
	1923	for ( ;; )
	1924	{
	1925	wxChar pathname[128];
	1926	wxPrintf(_T("\nEnter a directory name: "));
	1927	if ( !wxFgets(pathname, WXSIZEOF(pathname), stdin) )
	1928	break;
	1929
	1930	// kill the last '\n'
	1931	pathname[wxStrlen(pathname) - 1] = 0;
	1932
	1933	wxLongLong total, free;
	1934	if ( !wxGetDiskSpace(pathname, &total, &free) )
	1935	{
	1936	wxPuts(_T("ERROR: wxGetDiskSpace failed."));
	1937	}
	1938	else
	1939	{
	1940	wxPrintf(_T("%sKb total, %sKb free on '%s'.\n"),
	1941	(total / 1024).ToString().c_str(),
	1942	(free / 1024).ToString().c_str(),
	1943	pathname);
	1944	}
	1945	}
	1946	}
	1947
	1948	static void TestOsInfo()
	1949	{
	1950	wxPuts(_T("* Testing OS info functions *\n"));
	1951
	1952	int major, minor;
	1953	wxGetOsVersion(&major, &minor);
	1954	wxPrintf(_T("Running under: %s, version %d.%d\n"),
	1955	wxGetOsDescription().c_str(), major, minor);
	1956
	1957	wxPrintf(_T("%ld free bytes of memory left.\n"), wxGetFreeMemory());
	1958
	1959	wxPrintf(_T("Host name is %s (%s).\n"),
	1960	wxGetHostName().c_str(), wxGetFullHostName().c_str());
	1961
	1962	wxPuts(wxEmptyString);
	1963	}
	1964
	1965	static void TestUserInfo()
	1966	{
	1967	wxPuts(_T("* Testing user info functions *\n"));
	1968
	1969	wxPrintf(_T("User id is:\t%s\n"), wxGetUserId().c_str());
	1970	wxPrintf(_T("User name is:\t%s\n"), wxGetUserName().c_str());
	1971	wxPrintf(_T("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
	1972	wxPrintf(_T("Email address:\t%s\n"), wxGetEmailAddress().c_str());
	1973
	1974	wxPuts(wxEmptyString);
	1975	}
	1976
	1977	#endif // TEST_INFO_FUNCTIONS
	1978
	1979	// ----------------------------------------------------------------------------
	1980	// path list
	1981	// ----------------------------------------------------------------------------
	1982
	1983	#ifdef TEST_PATHLIST
	1984
	1985	#ifdef __UNIX__
	1986	#define CMD_IN_PATH _T("ls")
	1987	#else
	1988	#define CMD_IN_PATH _T("command.com")
	1989	#endif
	1990
	1991	static void TestPathList()
	1992	{
	1993	wxPuts(_T("* Testing wxPathList *\n"));
	1994
	1995	wxPathList pathlist;
	1996	pathlist.AddEnvList(_T("PATH"));
	1997	wxString path = pathlist.FindValidPath(CMD_IN_PATH);
	1998	if ( path.empty() )
	1999	{
	2000	wxPrintf(_T("ERROR: command not found in the path.\n"));
	2001	}
	2002	else
	2003	{
	2004	wxPrintf(_T("Command found in the path as '%s'.\n"), path.c_str());
	2005	}
	2006	}
	2007
	2008	#endif // TEST_PATHLIST
	2009
	2010	// ----------------------------------------------------------------------------
	2011	// regular expressions
	2012	// ----------------------------------------------------------------------------
	2013
	2014	#ifdef TEST_REGEX
	2015
	2016	#include "wx/regex.h"
	2017
	2018	static void TestRegExInteractive()
	2019	{
	2020	wxPuts(_T("* Testing RE interactively *"));
	2021
	2022	for ( ;; )
	2023	{
	2024	wxChar pattern[128];
	2025	wxPrintf(_T("\nEnter a pattern: "));
	2026	if ( !wxFgets(pattern, WXSIZEOF(pattern), stdin) )
	2027	break;
	2028
	2029	// kill the last '\n'
	2030	pattern[wxStrlen(pattern) - 1] = 0;
	2031
	2032	wxRegEx re;
	2033	if ( !re.Compile(pattern) )
	2034	{
	2035	continue;
	2036	}
	2037
	2038	wxChar text[128];
	2039	for ( ;; )
	2040	{
	2041	wxPrintf(_T("Enter text to match: "));
	2042	if ( !wxFgets(text, WXSIZEOF(text), stdin) )
	2043	break;
	2044
	2045	// kill the last '\n'
	2046	text[wxStrlen(text) - 1] = 0;
	2047
	2048	if ( !re.Matches(text) )
	2049	{
	2050	wxPrintf(_T("No match.\n"));
	2051	}
	2052	else
	2053	{
	2054	wxPrintf(_T("Pattern matches at '%s'\n"), re.GetMatch(text).c_str());
	2055
	2056	size_t start, len;
	2057	for ( size_t n = 1; ; n++ )
	2058	{
	2059	if ( !re.GetMatch(&start, &len, n) )
	2060	{
	2061	break;
	2062	}
	2063
	2064	wxPrintf(_T("Subexpr %u matched '%s'\n"),
	2065	n, wxString(text + start, len).c_str());
	2066	}
	2067	}
	2068	}
	2069	}
	2070	}
	2071
	2072	#endif // TEST_REGEX
	2073
	2074	// ----------------------------------------------------------------------------
	2075	// database
	2076	// ----------------------------------------------------------------------------
	2077
	2078	#if !wxUSE_ODBC
	2079	#undef TEST_ODBC
	2080	#endif
	2081
	2082	#ifdef TEST_ODBC
	2083
	2084	#include <wx/db.h>
	2085
	2086	static void TestDbOpen()
	2087	{
	2088	HENV henv;
	2089	wxDb db(henv);
	2090	}
	2091
	2092	#endif // TEST_ODBC
	2093
	2094	// ----------------------------------------------------------------------------
	2095	// printf() tests
	2096	// ----------------------------------------------------------------------------
	2097
	2098	/*
	2099	NB: this stuff was taken from the glibc test suite and modified to build
	2100	in wxWidgets: if I read the copyright below properly, this shouldn't
	2101	be a problem
	2102	*/
	2103
	2104	#ifdef TEST_PRINTF
	2105
	2106	#ifdef wxTEST_PRINTF
	2107	// use our functions from wxchar.cpp
	2108	#undef wxPrintf
	2109	#undef wxSprintf
	2110
	2111	// NB: do _not_ use ATTRIBUTE_PRINTF here, we have some invalid formats
	2112	// in the tests below
	2113	int wxPrintf( const wxChar *format, ... );
	2114	int wxSprintf( wxChar str, const wxChar format, ... );
	2115	#endif
	2116
	2117	#include "wx/longlong.h"
	2118
	2119	#include <float.h>
	2120
	2121	static void rfg1 (void);
	2122	static void rfg2 (void);
	2123
	2124
	2125	static void
	2126	fmtchk (const wxChar *fmt)
	2127	{
	2128	(void) wxPrintf(_T("%s:\t`"), fmt);
	2129	(void) wxPrintf(fmt, 0x12);
	2130	(void) wxPrintf(_T("'\n"));
	2131	}
	2132
	2133	static void
	2134	fmtst1chk (const wxChar *fmt)
	2135	{
	2136	(void) wxPrintf(_T("%s:\t`"), fmt);
	2137	(void) wxPrintf(fmt, 4, 0x12);
	2138	(void) wxPrintf(_T("'\n"));
	2139	}
	2140
	2141	static void
	2142	fmtst2chk (const wxChar *fmt)
	2143	{
	2144	(void) wxPrintf(_T("%s:\t`"), fmt);
	2145	(void) wxPrintf(fmt, 4, 4, 0x12);
	2146	(void) wxPrintf(_T("'\n"));
	2147	}
	2148
	2149	/* This page is covered by the following copyright: */
	2150
	2151	/* (C) Copyright C E Chew
	2152	*
	2153	* Feel free to copy, use and distribute this software provided:
	2154	*
	2155	* 1. you do not pretend that you wrote it
	2156	* 2. you leave this copyright notice intact.
	2157	*/
	2158
	2159	/*
	2160	* Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
	2161	*/
	2162
	2163	#define DEC -123
	2164	#define INT 255
	2165	#define UNS (~0)
	2166
	2167	/* Formatted Output Test
	2168	*
	2169	* This exercises the output formatting code.
	2170	*/
	2171
	2172	wxChar *PointerNull = NULL;
	2173
	2174	static void
	2175	fp_test (void)
	2176	{
	2177	int i, j, k, l;
	2178	wxChar buf[7];
	2179	wxChar *prefix = buf;
	2180	wxChar tp[20];
	2181
	2182	wxPuts(_T("\nFormatted output test"));
	2183	wxPrintf(_T("prefix 6d 6o 6x 6X 6u\n"));
	2184	wxStrcpy(prefix, _T("%"));
	2185	for (i = 0; i < 2; i++) {
	2186	for (j = 0; j < 2; j++) {
	2187	for (k = 0; k < 2; k++) {
	2188	for (l = 0; l < 2; l++) {
	2189	wxStrcpy(prefix, _T("%"));
	2190	if (i == 0) wxStrcat(prefix, _T("-"));
	2191	if (j == 0) wxStrcat(prefix, _T("+"));
	2192	if (k == 0) wxStrcat(prefix, _T("#"));
	2193	if (l == 0) wxStrcat(prefix, _T("0"));
	2194	wxPrintf(_T("%5s \|"), prefix);
	2195	wxStrcpy(tp, prefix);
	2196	wxStrcat(tp, _T("6d \|"));
	2197	wxPrintf(tp, DEC);
	2198	wxStrcpy(tp, prefix);
	2199	wxStrcat(tp, _T("6o \|"));
	2200	wxPrintf(tp, INT);
	2201	wxStrcpy(tp, prefix);
	2202	wxStrcat(tp, _T("6x \|"));
	2203	wxPrintf(tp, INT);
	2204	wxStrcpy(tp, prefix);
	2205	wxStrcat(tp, _T("6X \|"));
	2206	wxPrintf(tp, INT);
	2207	wxStrcpy(tp, prefix);
	2208	wxStrcat(tp, _T("6u \|"));
	2209	wxPrintf(tp, UNS);
	2210	wxPrintf(_T("\n"));
	2211	}
	2212	}
	2213	}
	2214	}
	2215	wxPrintf(_T("%10s\n"), PointerNull);
	2216	wxPrintf(_T("%-10s\n"), PointerNull);
	2217	}
	2218
	2219	static void TestPrintf()
	2220	{
	2221	static wxChar shortstr[] = _T("Hi, Z.");
	2222	static wxChar longstr[] = _T("Good morning, Doctor Chandra. This is Hal. \
	2223	I am ready for my first lesson today.");
	2224	int result = 0;
	2225	wxString test_format;
	2226
	2227	fmtchk(_T("%.4x"));
	2228	fmtchk(_T("%04x"));
	2229	fmtchk(_T("%4.4x"));
	2230	fmtchk(_T("%04.4x"));
	2231	fmtchk(_T("%4.3x"));
	2232	fmtchk(_T("%04.3x"));
	2233
	2234	fmtst1chk(_T("%.*x"));
	2235	fmtst1chk(_T("%0*x"));
	2236	fmtst2chk(_T("%.x"));
	2237	fmtst2chk(_T("%0.x"));
	2238
	2239	wxString bad_format = _T("bad format:\t\"%b\"\n");
	2240	wxPrintf(bad_format.c_str());
	2241	wxPrintf(_T("nil pointer (padded):\t\"%10p\"\n"), (void *) NULL);
	2242
	2243	wxPrintf(_T("decimal negative:\t\"%d\"\n"), -2345);
	2244	wxPrintf(_T("octal negative:\t\"%o\"\n"), -2345);
	2245	wxPrintf(_T("hex negative:\t\"%x\"\n"), -2345);
	2246	wxPrintf(_T("long decimal number:\t\"%ld\"\n"), -123456L);
	2247	wxPrintf(_T("long octal negative:\t\"%lo\"\n"), -2345L);
	2248	wxPrintf(_T("long unsigned decimal number:\t\"%lu\"\n"), -123456L);
	2249	wxPrintf(_T("zero-padded LDN:\t\"%010ld\"\n"), -123456L);
	2250	test_format = _T("left-adjusted ZLDN:\t\"%-010ld\"\n");
	2251	wxPrintf(test_format.c_str(), -123456);
	2252	wxPrintf(_T("space-padded LDN:\t\"%10ld\"\n"), -123456L);
	2253	wxPrintf(_T("left-adjusted SLDN:\t\"%-10ld\"\n"), -123456L);
	2254
	2255	test_format = _T("zero-padded string:\t\"%010s\"\n");
	2256	wxPrintf(test_format.c_str(), shortstr);
	2257	test_format = _T("left-adjusted Z string:\t\"%-010s\"\n");
	2258	wxPrintf(test_format.c_str(), shortstr);
	2259	wxPrintf(_T("space-padded string:\t\"%10s\"\n"), shortstr);
	2260	wxPrintf(_T("left-adjusted S string:\t\"%-10s\"\n"), shortstr);
	2261	wxPrintf(_T("null string:\t\"%s\"\n"), PointerNull);
	2262	wxPrintf(_T("limited string:\t\"%.22s\"\n"), longstr);
	2263
	2264	wxPrintf(_T("e-style >= 1:\t\"%e\"\n"), 12.34);
	2265	wxPrintf(_T("e-style >= .1:\t\"%e\"\n"), 0.1234);
	2266	wxPrintf(_T("e-style < .1:\t\"%e\"\n"), 0.001234);
	2267	wxPrintf(_T("e-style big:\t\"%.60e\"\n"), 1e20);
	2268	wxPrintf(_T("e-style == .1:\t\"%e\"\n"), 0.1);
	2269	wxPrintf(_T("f-style >= 1:\t\"%f\"\n"), 12.34);
	2270	wxPrintf(_T("f-style >= .1:\t\"%f\"\n"), 0.1234);
	2271	wxPrintf(_T("f-style < .1:\t\"%f\"\n"), 0.001234);
	2272	wxPrintf(_T("g-style >= 1:\t\"%g\"\n"), 12.34);
	2273	wxPrintf(_T("g-style >= .1:\t\"%g\"\n"), 0.1234);
	2274	wxPrintf(_T("g-style < .1:\t\"%g\"\n"), 0.001234);
	2275	wxPrintf(_T("g-style big:\t\"%.60g\"\n"), 1e20);
	2276
	2277	wxPrintf (_T(" %6.5f\n"), .099999999860301614);
	2278	wxPrintf (_T(" %6.5f\n"), .1);
	2279	wxPrintf (_T("x%5.4fx\n"), .5);
	2280
	2281	wxPrintf (_T("%#03x\n"), 1);
	2282
	2283	//wxPrintf (_T("something really insane: %.10000f\n"), 1.0);
	2284
	2285	{
	2286	double d = FLT_MIN;
	2287	int niter = 17;
	2288
	2289	while (niter-- != 0)
	2290	wxPrintf (_T("%.17e\n"), d / 2);
	2291	fflush (stdout);
	2292	}
	2293
	2294	#ifndef __WATCOMC__
	2295	// Open Watcom cause compiler error here
	2296	// Error! E173: col(24) floating-point constant too small to represent
	2297	wxPrintf (_T("%15.5e\n"), 4.9406564584124654e-324);
	2298	#endif
	2299
	2300	#define FORMAT _T("\|%12.4f\|%12.4e\|%12.4g\|\n")
	2301	wxPrintf (FORMAT, 0.0, 0.0, 0.0);
	2302	wxPrintf (FORMAT, 1.0, 1.0, 1.0);
	2303	wxPrintf (FORMAT, -1.0, -1.0, -1.0);
	2304	wxPrintf (FORMAT, 100.0, 100.0, 100.0);
	2305	wxPrintf (FORMAT, 1000.0, 1000.0, 1000.0);
	2306	wxPrintf (FORMAT, 10000.0, 10000.0, 10000.0);
	2307	wxPrintf (FORMAT, 12345.0, 12345.0, 12345.0);
	2308	wxPrintf (FORMAT, 100000.0, 100000.0, 100000.0);
	2309	wxPrintf (FORMAT, 123456.0, 123456.0, 123456.0);
	2310	#undef FORMAT
	2311
	2312	{
	2313	wxChar buf[20];
	2314	int rc = wxSnprintf (buf, WXSIZEOF(buf), _T("%30s"), _T("foo"));
	2315
	2316	wxPrintf(_T("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n"),
	2317	rc, WXSIZEOF(buf), buf);
	2318	#if 0
	2319	wxChar buf2[512];
	2320	wxPrintf ("snprintf (\"%%.999999u\", 10)\n",
	2321	wxSnprintf(buf2, WXSIZEOFbuf2), "%.999999u", 10));
	2322	#endif
	2323	}
	2324
	2325	fp_test ();
	2326
	2327	wxPrintf (_T("%e should be 1.234568e+06\n"), 1234567.8);
	2328	wxPrintf (_T("%f should be 1234567.800000\n"), 1234567.8);
	2329	wxPrintf (_T("%g should be 1.23457e+06\n"), 1234567.8);
	2330	wxPrintf (_T("%g should be 123.456\n"), 123.456);
	2331	wxPrintf (_T("%g should be 1e+06\n"), 1000000.0);
	2332	wxPrintf (_T("%g should be 10\n"), 10.0);
	2333	wxPrintf (_T("%g should be 0.02\n"), 0.02);
	2334
	2335	{
	2336	double x=1.0;
	2337	wxPrintf(_T("%.17f\n"),(1.0/x/10.0+1.0)*x-x);
	2338	}
	2339
	2340	{
	2341	wxChar buf[200];
	2342
	2343	wxSprintf(buf,_T("%s%s%*s"),-1,_T("one"),-20,_T("two"),-30,_T("three"));
	2344
	2345	result \|= wxStrcmp (buf,
	2346	_T("onetwo three "));
	2347
	2348	wxPuts (result != 0 ? _T("Test failed!") : _T("Test ok."));
	2349	}
	2350
	2351	#ifdef wxLongLong_t
	2352	{
	2353	wxChar buf[200];
	2354
	2355	wxSprintf(buf, _T("%07") wxLongLongFmtSpec _T("o"), wxLL(040000000000));
	2356	#if 0
	2357	// for some reason below line fails under Borland
	2358	wxPrintf (_T("sprintf (buf, \"%%07Lo\", 040000000000ll) = %s"), buf);
	2359	#endif
	2360
	2361	if (wxStrcmp (buf, _T("40000000000")) != 0)
	2362	{
	2363	result = 1;
	2364	wxPuts (_T("\tFAILED"));
	2365	}
	2366	wxUnusedVar(result);
	2367	wxPuts (wxEmptyString);
	2368	}
	2369	#endif // wxLongLong_t
	2370
	2371	wxPrintf (_T("printf (\"%%hhu\", %u) = %hhu\n"), UCHAR_MAX + 2, UCHAR_MAX + 2);
	2372	wxPrintf (_T("printf (\"%%hu\", %u) = %hu\n"), USHRT_MAX + 2, USHRT_MAX + 2);
	2373
	2374	wxPuts (_T("--- Should be no further output. ---"));
	2375	rfg1 ();
	2376	rfg2 ();
	2377
	2378	#if 0
	2379	{
	2380	wxChar bytes[7];
	2381	wxChar buf[20];
	2382
	2383	memset (bytes, '\xff', sizeof bytes);
	2384	wxSprintf (buf, _T("foo%hhn\n"), &bytes[3]);
	2385	if (bytes[0] != '\xff' \|\| bytes[1] != '\xff' \|\| bytes[2] != '\xff'
	2386	\|\| bytes[4] != '\xff' \|\| bytes[5] != '\xff' \|\| bytes[6] != '\xff')
	2387	{
	2388	wxPuts (_T("%hhn overwrite more bytes"));
	2389	result = 1;
	2390	}
	2391	if (bytes[3] != 3)
	2392	{
	2393	wxPuts (_T("%hhn wrote incorrect value"));
	2394	result = 1;
	2395	}
	2396	}
	2397	#endif
	2398	}
	2399
	2400	static void
	2401	rfg1 (void)
	2402	{
	2403	wxChar buf[100];
	2404
	2405	wxSprintf (buf, _T("%5.s"), _T("xyz"));
	2406	if (wxStrcmp (buf, _T(" ")) != 0)
	2407	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" "));
	2408	wxSprintf (buf, _T("%5.f"), 33.3);
	2409	if (wxStrcmp (buf, _T(" 33")) != 0)
	2410	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 33"));
	2411	wxSprintf (buf, _T("%8.e"), 33.3e7);
	2412	if (wxStrcmp (buf, _T(" 3e+08")) != 0)
	2413	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3e+08"));
	2414	wxSprintf (buf, _T("%8.E"), 33.3e7);
	2415	if (wxStrcmp (buf, _T(" 3E+08")) != 0)
	2416	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3E+08"));
	2417	wxSprintf (buf, _T("%.g"), 33.3);
	2418	if (wxStrcmp (buf, _T("3e+01")) != 0)
	2419	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3e+01"));
	2420	wxSprintf (buf, _T("%.G"), 33.3);
	2421	if (wxStrcmp (buf, _T("3E+01")) != 0)
	2422	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3E+01"));
	2423	}
	2424
	2425	static void
	2426	rfg2 (void)
	2427	{
	2428	int prec;
	2429	wxChar buf[100];
	2430	wxString test_format;
	2431
	2432	prec = 0;
	2433	wxSprintf (buf, _T("%.*g"), prec, 3.3);
	2434	if (wxStrcmp (buf, _T("3")) != 0)
	2435	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
	2436	prec = 0;
	2437	wxSprintf (buf, _T("%.*G"), prec, 3.3);
	2438	if (wxStrcmp (buf, _T("3")) != 0)
	2439	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T("3"));
	2440	prec = 0;
	2441	wxSprintf (buf, _T("%7.*G"), prec, 3.33);
	2442	if (wxStrcmp (buf, _T(" 3")) != 0)
	2443	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 3"));
	2444	prec = 3;
	2445	test_format = _T("%04.*o");
	2446	wxSprintf (buf, test_format.c_str(), prec, 33);
	2447	if (wxStrcmp (buf, _T(" 041")) != 0)
	2448	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 041"));
	2449	prec = 7;
	2450	test_format = _T("%09.*u");
	2451	wxSprintf (buf, test_format.c_str(), prec, 33);
	2452	if (wxStrcmp (buf, _T(" 0000033")) != 0)
	2453	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 0000033"));
	2454	prec = 3;
	2455	test_format = _T("%04.*x");
	2456	wxSprintf (buf, test_format.c_str(), prec, 33);
	2457	if (wxStrcmp (buf, _T(" 021")) != 0)
	2458	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
	2459	prec = 3;
	2460	test_format = _T("%04.*X");
	2461	wxSprintf (buf, test_format.c_str(), prec, 33);
	2462	if (wxStrcmp (buf, _T(" 021")) != 0)
	2463	wxPrintf (_T("got: '%s', expected: '%s'\n"), buf, _T(" 021"));
	2464	}
	2465
	2466	#endif // TEST_PRINTF
	2467
	2468	// ----------------------------------------------------------------------------
	2469	// registry and related stuff
	2470	// ----------------------------------------------------------------------------
	2471
	2472	// this is for MSW only
	2473	#ifndef __WXMSW__
	2474	#undef TEST_REGCONF
	2475	#undef TEST_REGISTRY
	2476	#endif
	2477
	2478	#ifdef TEST_REGCONF
	2479
	2480	#include "wx/confbase.h"
	2481	#include "wx/msw/regconf.h"
	2482
	2483	#if 0
	2484	static void TestRegConfWrite()
	2485	{
	2486	wxConfig *config = new wxConfig(_T("myapp"));
	2487	config->SetPath(_T("/group1"));
	2488	config->Write(_T("entry1"), _T("foo"));
	2489	config->SetPath(_T("/group2"));
	2490	config->Write(_T("entry1"), _T("bar"));
	2491	}
	2492	#endif
	2493
	2494	static void TestRegConfRead()
	2495	{
	2496	wxConfig *config = new wxConfig(_T("myapp"));
	2497
	2498	wxString str;
	2499	long dummy;
	2500	config->SetPath(_T("/"));
	2501	wxPuts(_T("Enumerating / subgroups:"));
	2502	bool bCont = config->GetFirstGroup(str, dummy);
	2503	while(bCont)
	2504	{
	2505	wxPuts(str);
	2506	bCont = config->GetNextGroup(str, dummy);
	2507	}
	2508	}
	2509
	2510	#endif // TEST_REGCONF
	2511
	2512	#ifdef TEST_REGISTRY
	2513
	2514	#include "wx/msw/registry.h"
	2515
	2516	// I chose this one because I liked its name, but it probably only exists under
	2517	// NT
	2518	static const wxChar *TESTKEY =
	2519	_T("HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Control\\CrashControl");
	2520
	2521	static void TestRegistryRead()
	2522	{
	2523	wxPuts(_T("* testing registry reading *"));
	2524
	2525	wxRegKey key(TESTKEY);
	2526	wxPrintf(_T("The test key name is '%s'.\n"), key.GetName().c_str());
	2527	if ( !key.Open() )
	2528	{
	2529	wxPuts(_T("ERROR: test key can't be opened, aborting test."));
	2530
	2531	return;
	2532	}
	2533
	2534	size_t nSubKeys, nValues;
	2535	if ( key.GetKeyInfo(&nSubKeys, NULL, &nValues, NULL) )
	2536	{
	2537	wxPrintf(_T("It has %u subkeys and %u values.\n"), nSubKeys, nValues);
	2538	}
	2539
	2540	wxPrintf(_T("Enumerating values:\n"));
	2541
	2542	long dummy;
	2543	wxString value;
	2544	bool cont = key.GetFirstValue(value, dummy);
	2545	while ( cont )
	2546	{
	2547	wxPrintf(_T("Value '%s': type "), value.c_str());
	2548	switch ( key.GetValueType(value) )
	2549	{
	2550	case wxRegKey::Type_None: wxPrintf(_T("ERROR (none)")); break;
	2551	case wxRegKey::Type_String: wxPrintf(_T("SZ")); break;
	2552	case wxRegKey::Type_Expand_String: wxPrintf(_T("EXPAND_SZ")); break;
	2553	case wxRegKey::Type_Binary: wxPrintf(_T("BINARY")); break;
	2554	case wxRegKey::Type_Dword: wxPrintf(_T("DWORD")); break;
	2555	case wxRegKey::Type_Multi_String: wxPrintf(_T("MULTI_SZ")); break;
	2556	default: wxPrintf(_T("other (unknown)")); break;
	2557	}
	2558
	2559	wxPrintf(_T(", value = "));
	2560	if ( key.IsNumericValue(value) )
	2561	{
	2562	long val;
	2563	key.QueryValue(value, &val);
	2564	wxPrintf(_T("%ld"), val);
	2565	}
	2566	else // string
	2567	{
	2568	wxString val;
	2569	key.QueryValue(value, val);
	2570	wxPrintf(_T("'%s'"), val.c_str());
	2571
	2572	key.QueryRawValue(value, val);
	2573	wxPrintf(_T(" (raw value '%s')"), val.c_str());
	2574	}
	2575
	2576	wxPutchar('\n');
	2577
	2578	cont = key.GetNextValue(value, dummy);
	2579	}
	2580	}
	2581
	2582	static void TestRegistryAssociation()
	2583	{
	2584	/*
	2585	The second call to deleteself genertaes an error message, with a
	2586	messagebox saying .flo is crucial to system operation, while the .ddf
	2587	call also fails, but with no error message
	2588	*/
	2589
	2590	wxRegKey key;
	2591
	2592	key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
	2593	key.Create();
	2594	key = _T("ddxf_auto_file") ;
	2595	key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
	2596	key.Create();
	2597	key = _T("ddxf_auto_file") ;
	2598	key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
	2599	key.Create();
	2600	key = _T("program,0") ;
	2601	key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
	2602	key.Create();
	2603	key = _T("program \"%1\"") ;
	2604
	2605	key.SetName(_T("HKEY_CLASSES_ROOT\\.ddf") );
	2606	key.DeleteSelf();
	2607	key.SetName(_T("HKEY_CLASSES_ROOT\\.flo") );
	2608	key.DeleteSelf();
	2609	key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\DefaultIcon"));
	2610	key.DeleteSelf();
	2611	key.SetName(_T("HKEY_CLASSES_ROOT\\ddxf_auto_file\\shell\\open\\command"));
	2612	key.DeleteSelf();
	2613	}
	2614
	2615	#endif // TEST_REGISTRY
	2616
	2617	// ----------------------------------------------------------------------------
	2618	// scope guard
	2619	// ----------------------------------------------------------------------------
	2620
	2621	#ifdef TEST_SCOPEGUARD
	2622
	2623	#include "wx/scopeguard.h"
	2624
	2625	static void function0() { puts("function0()"); }
	2626	static void function1(int n) { printf("function1(%d)\n", n); }
	2627	static void function2(double x, char c) { printf("function2(%g, %c)\n", x, c); }
	2628
	2629	struct Object
	2630	{
	2631	void method0() { printf("method0()\n"); }
	2632	void method1(int n) { printf("method1(%d)\n", n); }
	2633	void method2(double x, char c) { printf("method2(%g, %c)\n", x, c); }
	2634	};
	2635
	2636	static void TestScopeGuard()
	2637	{
	2638	wxON_BLOCK_EXIT0(function0);
	2639	wxON_BLOCK_EXIT1(function1, 17);
	2640	wxON_BLOCK_EXIT2(function2, 3.14, 'p');
	2641
	2642	Object obj;
	2643	wxON_BLOCK_EXIT_OBJ0(obj, &Object::method0);
	2644	wxON_BLOCK_EXIT_OBJ1(obj, &Object::method1, 7);
	2645	wxON_BLOCK_EXIT_OBJ2(obj, &Object::method2, 2.71, 'e');
	2646
	2647	wxScopeGuard dismissed = wxMakeGuard(function0);
	2648	dismissed.Dismiss();
	2649	}
	2650
	2651	#endif
	2652
	2653	// ----------------------------------------------------------------------------
	2654	// sockets
	2655	// ----------------------------------------------------------------------------
	2656
	2657	#ifdef TEST_SOCKETS
	2658
	2659	#include "wx/socket.h"
	2660	#include "wx/protocol/protocol.h"
	2661	#include "wx/protocol/http.h"
	2662
	2663	static void TestSocketServer()
	2664	{
	2665	wxPuts(_T("* Testing wxSocketServer *\n"));
	2666
	2667	static const int PORT = 3000;
	2668
	2669	wxIPV4address addr;
	2670	addr.Service(PORT);
	2671
	2672	wxSocketServer *server = new wxSocketServer(addr);
	2673	if ( !server->Ok() )
	2674	{
	2675	wxPuts(_T("ERROR: failed to bind"));
	2676
	2677	return;
	2678	}
	2679
	2680	bool quit = false;
	2681	while ( !quit )
	2682	{
	2683	wxPrintf(_T("Server: waiting for connection on port %d...\n"), PORT);
	2684
	2685	wxSocketBase *socket = server->Accept();
	2686	if ( !socket )
	2687	{
	2688	wxPuts(_T("ERROR: wxSocketServer::Accept() failed."));
	2689	break;
	2690	}
	2691
	2692	wxPuts(_T("Server: got a client."));
	2693
	2694	server->SetTimeout(60); // 1 min
	2695
	2696	bool close = false;
	2697	while ( !close && socket->IsConnected() )
	2698	{
	2699	wxString s;
	2700	wxChar ch = _T('\0');
	2701	for ( ;; )
	2702	{
	2703	if ( socket->Read(&ch, sizeof(ch)).Error() )
	2704	{
	2705	// don't log error if the client just close the connection
	2706	if ( socket->IsConnected() )
	2707	{
	2708	wxPuts(_T("ERROR: in wxSocket::Read."));
	2709	}
	2710
	2711	break;
	2712	}
	2713
	2714	if ( ch == '\r' )
	2715	continue;
	2716
	2717	if ( ch == '\n' )
	2718	break;
	2719
	2720	s += ch;
	2721	}
	2722
	2723	if ( ch != '\n' )
	2724	{
	2725	break;
	2726	}
	2727
	2728	wxPrintf(_T("Server: got '%s'.\n"), s.c_str());
	2729	if ( s == _T("close") )
	2730	{
	2731	wxPuts(_T("Closing connection"));
	2732
	2733	close = true;
	2734	}
	2735	else if ( s == _T("quit") )
	2736	{
	2737	close =
	2738	quit = true;
	2739
	2740	wxPuts(_T("Shutting down the server"));
	2741	}
	2742	else // not a special command
	2743	{
	2744	socket->Write(s.MakeUpper().c_str(), s.length());
	2745	socket->Write("\r\n", 2);
	2746	wxPrintf(_T("Server: wrote '%s'.\n"), s.c_str());
	2747	}
	2748	}
	2749
	2750	if ( !close )
	2751	{
	2752	wxPuts(_T("Server: lost a client unexpectedly."));
	2753	}
	2754
	2755	socket->Destroy();
	2756	}
	2757
	2758	// same as "delete server" but is consistent with GUI programs
	2759	server->Destroy();
	2760	}
	2761
	2762	static void TestSocketClient()
	2763	{
	2764	wxPuts(_T("* Testing wxSocketClient *\n"));
	2765
	2766	static const wxChar *hostname = _T("www.wxwidgets.org");
	2767
	2768	wxIPV4address addr;
	2769	addr.Hostname(hostname);
	2770	addr.Service(80);
	2771
	2772	wxPrintf(_T("--- Attempting to connect to %s:80...\n"), hostname);
	2773
	2774	wxSocketClient client;
	2775	if ( !client.Connect(addr) )
	2776	{
	2777	wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
	2778	}
	2779	else
	2780	{
	2781	wxPrintf(_T("--- Connected to %s:%u...\n"),
	2782	addr.Hostname().c_str(), addr.Service());
	2783
	2784	wxChar buf[8192];
	2785
	2786	// could use simply "GET" here I suppose
	2787	wxString cmdGet =
	2788	wxString::Format(_T("GET http://%s/\r\n"), hostname);
	2789	client.Write(cmdGet, cmdGet.length());
	2790	wxPrintf(_T("--- Sent command '%s' to the server\n"),
	2791	MakePrintable(cmdGet).c_str());
	2792	client.Read(buf, WXSIZEOF(buf));
	2793	wxPrintf(_T("--- Server replied:\n%s"), buf);
	2794	}
	2795	}
	2796
	2797	#endif // TEST_SOCKETS
	2798
	2799	// ----------------------------------------------------------------------------
	2800	// FTP
	2801	// ----------------------------------------------------------------------------
	2802
	2803	#ifdef TEST_FTP
	2804
	2805	#include "wx/protocol/ftp.h"
	2806
	2807	static wxFTP ftp;
	2808
	2809	#define FTP_ANONYMOUS
	2810
	2811	#ifdef FTP_ANONYMOUS
	2812	static const wxChar *directory = _T("/pub");
	2813	static const wxChar *filename = _T("welcome.msg");
	2814	#else
	2815	static const wxChar *directory = _T("/etc");
	2816	static const wxChar *filename = _T("issue");
	2817	#endif
	2818
	2819	static bool TestFtpConnect()
	2820	{
	2821	wxPuts(_T("* Testing FTP connect *"));
	2822
	2823	#ifdef FTP_ANONYMOUS
	2824	static const wxChar *hostname = _T("ftp.wxwidgets.org");
	2825
	2826	wxPrintf(_T("--- Attempting to connect to %s:21 anonymously...\n"), hostname);
	2827	#else // !FTP_ANONYMOUS
	2828	static const wxChar *hostname = "localhost";
	2829
	2830	wxChar user[256];
	2831	wxFgets(user, WXSIZEOF(user), stdin);
	2832	user[wxStrlen(user) - 1] = '\0'; // chop off '\n'
	2833	ftp.SetUser(user);
	2834
	2835	wxChar password[256];
	2836	wxPrintf(_T("Password for %s: "), password);
	2837	wxFgets(password, WXSIZEOF(password), stdin);
	2838	password[wxStrlen(password) - 1] = '\0'; // chop off '\n'
	2839	ftp.SetPassword(password);
	2840
	2841	wxPrintf(_T("--- Attempting to connect to %s:21 as %s...\n"), hostname, user);
	2842	#endif // FTP_ANONYMOUS/!FTP_ANONYMOUS
	2843
	2844	if ( !ftp.Connect(hostname) )
	2845	{
	2846	wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
	2847
	2848	return false;
	2849	}
	2850	else
	2851	{
	2852	wxPrintf(_T("--- Connected to %s, current directory is '%s'\n"),
	2853	hostname, ftp.Pwd().c_str());
	2854	}
	2855
	2856	return true;
	2857	}
	2858
	2859	// test (fixed?) wxFTP bug with wu-ftpd >= 2.6.0?
	2860	static void TestFtpWuFtpd()
	2861	{
	2862	wxFTP ftp;
	2863	static const wxChar *hostname = _T("ftp.eudora.com");
	2864	if ( !ftp.Connect(hostname) )
	2865	{
	2866	wxPrintf(_T("ERROR: failed to connect to %s\n"), hostname);
	2867	}
	2868	else
	2869	{
	2870	static const wxChar *filename = _T("eudora/pubs/draft-gellens-submit-09.txt");
	2871	wxInputStream *in = ftp.GetInputStream(filename);
	2872	if ( !in )
	2873	{
	2874	wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
	2875	}
	2876	else
	2877	{
	2878	size_t size = in->GetSize();
	2879	wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
	2880
	2881	wxChar *data = new wxChar[size];
	2882	if ( !in->Read(data, size) )
	2883	{
	2884	wxPuts(_T("ERROR: read error"));
	2885	}
	2886	else
	2887	{
	2888	wxPrintf(_T("Successfully retrieved the file.\n"));
	2889	}
	2890
	2891	delete [] data;
	2892	delete in;
	2893	}
	2894	}
	2895	}
	2896
	2897	static void TestFtpList()
	2898	{
	2899	wxPuts(_T("* Testing wxFTP file listing *\n"));
	2900
	2901	// test CWD
	2902	if ( !ftp.ChDir(directory) )
	2903	{
	2904	wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
	2905	}
	2906
	2907	wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
	2908
	2909	// test NLIST and LIST
	2910	wxArrayString files;
	2911	if ( !ftp.GetFilesList(files) )
	2912	{
	2913	wxPuts(_T("ERROR: failed to get NLIST of files"));
	2914	}
	2915	else
	2916	{
	2917	wxPrintf(_T("Brief list of files under '%s':\n"), ftp.Pwd().c_str());
	2918	size_t count = files.GetCount();
	2919	for ( size_t n = 0; n < count; n++ )
	2920	{
	2921	wxPrintf(_T("\t%s\n"), files[n].c_str());
	2922	}
	2923	wxPuts(_T("End of the file list"));
	2924	}
	2925
	2926	if ( !ftp.GetDirList(files) )
	2927	{
	2928	wxPuts(_T("ERROR: failed to get LIST of files"));
	2929	}
	2930	else
	2931	{
	2932	wxPrintf(_T("Detailed list of files under '%s':\n"), ftp.Pwd().c_str());
	2933	size_t count = files.GetCount();
	2934	for ( size_t n = 0; n < count; n++ )
	2935	{
	2936	wxPrintf(_T("\t%s\n"), files[n].c_str());
	2937	}
	2938	wxPuts(_T("End of the file list"));
	2939	}
	2940
	2941	if ( !ftp.ChDir(_T("..")) )
	2942	{
	2943	wxPuts(_T("ERROR: failed to cd to .."));
	2944	}
	2945
	2946	wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
	2947	}
	2948
	2949	static void TestFtpDownload()
	2950	{
	2951	wxPuts(_T("* Testing wxFTP download *\n"));
	2952
	2953	// test RETR
	2954	wxInputStream *in = ftp.GetInputStream(filename);
	2955	if ( !in )
	2956	{
	2957	wxPrintf(_T("ERROR: couldn't get input stream for %s\n"), filename);
	2958	}
	2959	else
	2960	{
	2961	size_t size = in->GetSize();
	2962	wxPrintf(_T("Reading file %s (%u bytes)..."), filename, size);
	2963	fflush(stdout);
	2964
	2965	wxChar *data = new wxChar[size];
	2966	if ( !in->Read(data, size) )
	2967	{
	2968	wxPuts(_T("ERROR: read error"));
	2969	}
	2970	else
	2971	{
	2972	wxPrintf(_T("\nContents of %s:\n%s\n"), filename, data);
	2973	}
	2974
	2975	delete [] data;
	2976	delete in;
	2977	}
	2978	}
	2979
	2980	static void TestFtpFileSize()
	2981	{
	2982	wxPuts(_T("* Testing FTP SIZE command *"));
	2983
	2984	if ( !ftp.ChDir(directory) )
	2985	{
	2986	wxPrintf(_T("ERROR: failed to cd to %s\n"), directory);
	2987	}
	2988
	2989	wxPrintf(_T("Current directory is '%s'\n"), ftp.Pwd().c_str());
	2990
	2991	if ( ftp.FileExists(filename) )
	2992	{
	2993	int size = ftp.GetFileSize(filename);
	2994	if ( size == -1 )
	2995	wxPrintf(_T("ERROR: couldn't get size of '%s'\n"), filename);
	2996	else
	2997	wxPrintf(_T("Size of '%s' is %d bytes.\n"), filename, size);
	2998	}
	2999	else
	3000	{
	3001	wxPrintf(_T("ERROR: '%s' doesn't exist\n"), filename);
	3002	}
	3003	}
	3004
	3005	static void TestFtpMisc()
	3006	{
	3007	wxPuts(_T("* Testing miscellaneous wxFTP functions *"));
	3008
	3009	if ( ftp.SendCommand(_T("STAT")) != '2' )
	3010	{
	3011	wxPuts(_T("ERROR: STAT failed"));
	3012	}
	3013	else
	3014	{
	3015	wxPrintf(_T("STAT returned:\n\n%s\n"), ftp.GetLastResult().c_str());
	3016	}
	3017
	3018	if ( ftp.SendCommand(_T("HELP SITE")) != '2' )
	3019	{
	3020	wxPuts(_T("ERROR: HELP SITE failed"));
	3021	}
	3022	else
	3023	{
	3024	wxPrintf(_T("The list of site-specific commands:\n\n%s\n"),
	3025	ftp.GetLastResult().c_str());
	3026	}
	3027	}
	3028
	3029	static void TestFtpInteractive()
	3030	{
	3031	wxPuts(_T("\n* Interactive wxFTP test *"));
	3032
	3033	wxChar buf[128];
	3034
	3035	for ( ;; )
	3036	{
	3037	wxPrintf(_T("Enter FTP command: "));
	3038	if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
	3039	break;
	3040
	3041	// kill the last '\n'
	3042	buf[wxStrlen(buf) - 1] = 0;
	3043
	3044	// special handling of LIST and NLST as they require data connection
	3045	wxString start(buf, 4);
	3046	start.MakeUpper();
	3047	if ( start == _T("LIST") \|\| start == _T("NLST") )
	3048	{
	3049	wxString wildcard;
	3050	if ( wxStrlen(buf) > 4 )
	3051	wildcard = buf + 5;
	3052
	3053	wxArrayString files;
	3054	if ( !ftp.GetList(files, wildcard, start == _T("LIST")) )
	3055	{
	3056	wxPrintf(_T("ERROR: failed to get %s of files\n"), start.c_str());
	3057	}
	3058	else
	3059	{
	3060	wxPrintf(_T("--- %s of '%s' under '%s':\n"),
	3061	start.c_str(), wildcard.c_str(), ftp.Pwd().c_str());
	3062	size_t count = files.GetCount();
	3063	for ( size_t n = 0; n < count; n++ )
	3064	{
	3065	wxPrintf(_T("\t%s\n"), files[n].c_str());
	3066	}
	3067	wxPuts(_T("--- End of the file list"));
	3068	}
	3069	}
	3070	else // !list
	3071	{
	3072	wxChar ch = ftp.SendCommand(buf);
	3073	wxPrintf(_T("Command %s"), ch ? _T("succeeded") : _T("failed"));
	3074	if ( ch )
	3075	{
	3076	wxPrintf(_T(" (return code %c)"), ch);
	3077	}
	3078
	3079	wxPrintf(_T(", server reply:\n%s\n\n"), ftp.GetLastResult().c_str());
	3080	}
	3081	}
	3082
	3083	wxPuts(_T("\n* done *"));
	3084	}
	3085
	3086	static void TestFtpUpload()
	3087	{
	3088	wxPuts(_T("* Testing wxFTP uploading *\n"));
	3089
	3090	// upload a file
	3091	static const wxChar *file1 = _T("test1");
	3092	static const wxChar *file2 = _T("test2");
	3093	wxOutputStream *out = ftp.GetOutputStream(file1);
	3094	if ( out )
	3095	{
	3096	wxPrintf(_T("--- Uploading to %s ---\n"), file1);
	3097	out->Write("First hello", 11);
	3098	delete out;
	3099	}
	3100
	3101	// send a command to check the remote file
	3102	if ( ftp.SendCommand(wxString(_T("STAT ")) + file1) != '2' )
	3103	{
	3104	wxPrintf(_T("ERROR: STAT %s failed\n"), file1);
	3105	}
	3106	else
	3107	{
	3108	wxPrintf(_T("STAT %s returned:\n\n%s\n"),
	3109	file1, ftp.GetLastResult().c_str());
	3110	}
	3111
	3112	out = ftp.GetOutputStream(file2);
	3113	if ( out )
	3114	{
	3115	wxPrintf(_T("--- Uploading to %s ---\n"), file1);
	3116	out->Write("Second hello", 12);
	3117	delete out;
	3118	}
	3119	}
	3120
	3121	#endif // TEST_FTP
	3122
	3123	// ----------------------------------------------------------------------------
	3124	// streams
	3125	// ----------------------------------------------------------------------------
	3126
	3127	#ifdef TEST_STREAMS
	3128
	3129	#include "wx/wfstream.h"
	3130	#include "wx/mstream.h"
	3131
	3132	static void TestFileStream()
	3133	{
	3134	wxPuts(_T("* Testing wxFileInputStream *"));
	3135
	3136	static const wxString filename = _T("testdata.fs");
	3137	{
	3138	wxFileOutputStream fsOut(filename);
	3139	fsOut.Write("foo", 3);
	3140	}
	3141
	3142	wxFileInputStream fsIn(filename);
	3143	wxPrintf(_T("File stream size: %u\n"), fsIn.GetSize());
	3144	while ( !fsIn.Eof() )
	3145	{
	3146	wxPutchar(fsIn.GetC());
	3147	}
	3148
	3149	if ( !wxRemoveFile(filename) )
	3150	{
	3151	wxPrintf(_T("ERROR: failed to remove the file '%s'.\n"), filename.c_str());
	3152	}
	3153
	3154	wxPuts(_T("\n* wxFileInputStream test done *"));
	3155	}
	3156
	3157	static void TestMemoryStream()
	3158	{
	3159	wxPuts(_T("* Testing wxMemoryOutputStream *"));
	3160
	3161	wxMemoryOutputStream memOutStream;
	3162	wxPrintf(_T("Initially out stream offset: %lu\n"),
	3163	(unsigned long)memOutStream.TellO());
	3164
	3165	for ( const wxChar p = _T("Hello, stream!"); p; p++ )
	3166	{
	3167	memOutStream.PutC(*p);
	3168	}
	3169
	3170	wxPrintf(_T("Final out stream offset: %lu\n"),
	3171	(unsigned long)memOutStream.TellO());
	3172
	3173	wxPuts(_T("* Testing wxMemoryInputStream *"));
	3174
	3175	wxChar buf[1024];
	3176	size_t len = memOutStream.CopyTo(buf, WXSIZEOF(buf));
	3177
	3178	wxMemoryInputStream memInpStream(buf, len);
	3179	wxPrintf(_T("Memory stream size: %u\n"), memInpStream.GetSize());
	3180	while ( !memInpStream.Eof() )
	3181	{
	3182	wxPutchar(memInpStream.GetC());
	3183	}
	3184
	3185	wxPuts(_T("\n* wxMemoryInputStream test done *"));
	3186	}
	3187
	3188	#endif // TEST_STREAMS
	3189
	3190	// ----------------------------------------------------------------------------
	3191	// timers
	3192	// ----------------------------------------------------------------------------
	3193
	3194	#ifdef TEST_TIMER
	3195
	3196	#include "wx/timer.h"
	3197	#include "wx/utils.h"
	3198
	3199	static void TestStopWatch()
	3200	{
	3201	wxPuts(_T("* Testing wxStopWatch *\n"));
	3202
	3203	wxStopWatch sw;
	3204	sw.Pause();
	3205	wxPrintf(_T("Initially paused, after 2 seconds time is..."));
	3206	fflush(stdout);
	3207	wxSleep(2);
	3208	wxPrintf(_T("\t%ldms\n"), sw.Time());
	3209
	3210	wxPrintf(_T("Resuming stopwatch and sleeping 3 seconds..."));
	3211	fflush(stdout);
	3212	sw.Resume();
	3213	wxSleep(3);
	3214	wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
	3215
	3216	sw.Pause();
	3217	wxPrintf(_T("Pausing agan and sleeping 2 more seconds..."));
	3218	fflush(stdout);
	3219	wxSleep(2);
	3220	wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
	3221
	3222	sw.Resume();
	3223	wxPrintf(_T("Finally resuming and sleeping 2 more seconds..."));
	3224	fflush(stdout);
	3225	wxSleep(2);
	3226	wxPrintf(_T("\telapsed time: %ldms\n"), sw.Time());
	3227
	3228	wxStopWatch sw2;
	3229	wxPuts(_T("\nChecking for 'backwards clock' bug..."));
	3230	for ( size_t n = 0; n < 70; n++ )
	3231	{
	3232	sw2.Start();
	3233
	3234	for ( size_t m = 0; m < 100000; m++ )
	3235	{
	3236	if ( sw.Time() < 0 \|\| sw2.Time() < 0 )
	3237	{
	3238	wxPuts(_T("\ntime is negative - ERROR!"));
	3239	}
	3240	}
	3241
	3242	wxPutchar('.');
	3243	fflush(stdout);
	3244	}
	3245
	3246	wxPuts(_T(", ok."));
	3247	}
	3248
	3249	#endif // TEST_TIMER
	3250
	3251	// ----------------------------------------------------------------------------
	3252	// vCard support
	3253	// ----------------------------------------------------------------------------
	3254
	3255	#ifdef TEST_VCARD
	3256
	3257	#include "wx/vcard.h"
	3258
	3259	static void DumpVObject(size_t level, const wxVCardObject& vcard)
	3260	{
	3261	void *cookie;
	3262	wxVCardObject *vcObj = vcard.GetFirstProp(&cookie);
	3263	while ( vcObj )
	3264	{
	3265	wxPrintf(_T("%s%s"),
	3266	wxString(_T('\t'), level).c_str(),
	3267	vcObj->GetName().c_str());
	3268
	3269	wxString value;
	3270	switch ( vcObj->GetType() )
	3271	{
	3272	case wxVCardObject::String:
	3273	case wxVCardObject::UString:
	3274	{
	3275	wxString val;
	3276	vcObj->GetValue(&val);
	3277	value << _T('"') << val << _T('"');
	3278	}
	3279	break;
	3280
	3281	case wxVCardObject::Int:
	3282	{
	3283	unsigned int i;
	3284	vcObj->GetValue(&i);
	3285	value.Printf(_T("%u"), i);
	3286	}
	3287	break;
	3288
	3289	case wxVCardObject::Long:
	3290	{
	3291	unsigned long l;
	3292	vcObj->GetValue(&l);
	3293	value.Printf(_T("%lu"), l);
	3294	}
	3295	break;
	3296
	3297	case wxVCardObject::None:
	3298	break;
	3299
	3300	case wxVCardObject::Object:
	3301	value = _T("<node>");
	3302	break;
	3303
	3304	default:
	3305	value = _T("<unknown value type>");
	3306	}
	3307
	3308	if ( !!value )
	3309	wxPrintf(_T(" = %s"), value.c_str());
	3310	wxPutchar('\n');
	3311
	3312	DumpVObject(level + 1, *vcObj);
	3313
	3314	delete vcObj;
	3315	vcObj = vcard.GetNextProp(&cookie);
	3316	}
	3317	}
	3318
	3319	static void DumpVCardAddresses(const wxVCard& vcard)
	3320	{
	3321	wxPuts(_T("\nShowing all addresses from vCard:\n"));
	3322
	3323	size_t nAdr = 0;
	3324	void *cookie;
	3325	wxVCardAddress *addr = vcard.GetFirstAddress(&cookie);
	3326	while ( addr )
	3327	{
	3328	wxString flagsStr;
	3329	int flags = addr->GetFlags();
	3330	if ( flags & wxVCardAddress::Domestic )
	3331	{
	3332	flagsStr << _T("domestic ");
	3333	}
	3334	if ( flags & wxVCardAddress::Intl )
	3335	{
	3336	flagsStr << _T("international ");
	3337	}
	3338	if ( flags & wxVCardAddress::Postal )
	3339	{
	3340	flagsStr << _T("postal ");
	3341	}
	3342	if ( flags & wxVCardAddress::Parcel )
	3343	{
	3344	flagsStr << _T("parcel ");
	3345	}
	3346	if ( flags & wxVCardAddress::Home )
	3347	{
	3348	flagsStr << _T("home ");
	3349	}
	3350	if ( flags & wxVCardAddress::Work )
	3351	{
	3352	flagsStr << _T("work ");
	3353	}
	3354
	3355	wxPrintf(_T("Address %u:\n")
	3356	"\tflags = %s\n"
	3357	"\tvalue = %s;%s;%s;%s;%s;%s;%s\n",
	3358	++nAdr,
	3359	flagsStr.c_str(),
	3360	addr->GetPostOffice().c_str(),
	3361	addr->GetExtAddress().c_str(),
	3362	addr->GetStreet().c_str(),
	3363	addr->GetLocality().c_str(),
	3364	addr->GetRegion().c_str(),
	3365	addr->GetPostalCode().c_str(),
	3366	addr->GetCountry().c_str()
	3367	);
	3368
	3369	delete addr;
	3370	addr = vcard.GetNextAddress(&cookie);
	3371	}
	3372	}
	3373
	3374	static void DumpVCardPhoneNumbers(const wxVCard& vcard)
	3375	{
	3376	wxPuts(_T("\nShowing all phone numbers from vCard:\n"));
	3377
	3378	size_t nPhone = 0;
	3379	void *cookie;
	3380	wxVCardPhoneNumber *phone = vcard.GetFirstPhoneNumber(&cookie);
	3381	while ( phone )
	3382	{
	3383	wxString flagsStr;
	3384	int flags = phone->GetFlags();
	3385	if ( flags & wxVCardPhoneNumber::Voice )
	3386	{
	3387	flagsStr << _T("voice ");
	3388	}
	3389	if ( flags & wxVCardPhoneNumber::Fax )
	3390	{
	3391	flagsStr << _T("fax ");
	3392	}
	3393	if ( flags & wxVCardPhoneNumber::Cellular )
	3394	{
	3395	flagsStr << _T("cellular ");
	3396	}
	3397	if ( flags & wxVCardPhoneNumber::Modem )
	3398	{
	3399	flagsStr << _T("modem ");
	3400	}
	3401	if ( flags & wxVCardPhoneNumber::Home )
	3402	{
	3403	flagsStr << _T("home ");
	3404	}
	3405	if ( flags & wxVCardPhoneNumber::Work )
	3406	{
	3407	flagsStr << _T("work ");
	3408	}
	3409
	3410	wxPrintf(_T("Phone number %u:\n")
	3411	"\tflags = %s\n"
	3412	"\tvalue = %s\n",
	3413	++nPhone,
	3414	flagsStr.c_str(),
	3415	phone->GetNumber().c_str()
	3416	);
	3417
	3418	delete phone;
	3419	phone = vcard.GetNextPhoneNumber(&cookie);
	3420	}
	3421	}
	3422
	3423	static void TestVCardRead()
	3424	{
	3425	wxPuts(_T("* Testing wxVCard reading *\n"));
	3426
	3427	wxVCard vcard(_T("vcard.vcf"));
	3428	if ( !vcard.IsOk() )
	3429	{
	3430	wxPuts(_T("ERROR: couldn't load vCard."));
	3431	}
	3432	else
	3433	{
	3434	// read individual vCard properties
	3435	wxVCardObject *vcObj = vcard.GetProperty("FN");
	3436	wxString value;
	3437	if ( vcObj )
	3438	{
	3439	vcObj->GetValue(&value);
	3440	delete vcObj;
	3441	}
	3442	else
	3443	{
	3444	value = _T("<none>");
	3445	}
	3446
	3447	wxPrintf(_T("Full name retrieved directly: %s\n"), value.c_str());
	3448
	3449
	3450	if ( !vcard.GetFullName(&value) )
	3451	{
	3452	value = _T("<none>");
	3453	}
	3454
	3455	wxPrintf(_T("Full name from wxVCard API: %s\n"), value.c_str());
	3456
	3457	// now show how to deal with multiply occuring properties
	3458	DumpVCardAddresses(vcard);
	3459	DumpVCardPhoneNumbers(vcard);
	3460
	3461	// and finally show all
	3462	wxPuts(_T("\nNow dumping the entire vCard:\n")
	3463	"-----------------------------\n");
	3464
	3465	DumpVObject(0, vcard);
	3466	}
	3467	}
	3468
	3469	static void TestVCardWrite()
	3470	{
	3471	wxPuts(_T("* Testing wxVCard writing *\n"));
	3472
	3473	wxVCard vcard;
	3474	if ( !vcard.IsOk() )
	3475	{
	3476	wxPuts(_T("ERROR: couldn't create vCard."));
	3477	}
	3478	else
	3479	{
	3480	// set some fields
	3481	vcard.SetName("Zeitlin", "Vadim");
	3482	vcard.SetFullName("Vadim Zeitlin");
	3483	vcard.SetOrganization("wxWidgets", "R&D");
	3484
	3485	// just dump the vCard back
	3486	wxPuts(_T("Entire vCard follows:\n"));
	3487	wxPuts(vcard.Write());
	3488	}
	3489	}
	3490
	3491	#endif // TEST_VCARD
	3492
	3493	// ----------------------------------------------------------------------------
	3494	// wxVolume tests
	3495	// ----------------------------------------------------------------------------
	3496
	3497	#if !defined(__WIN32__) \|\| !wxUSE_FSVOLUME
	3498	#undef TEST_VOLUME
	3499	#endif
	3500
	3501	#ifdef TEST_VOLUME
	3502
	3503	#include "wx/volume.h"
	3504
	3505	static const wxChar *volumeKinds[] =
	3506	{
	3507	_T("floppy"),
	3508	_T("hard disk"),
	3509	_T("CD-ROM"),
	3510	_T("DVD-ROM"),
	3511	_T("network volume"),
	3512	_T("other volume"),
	3513	};
	3514
	3515	static void TestFSVolume()
	3516	{
	3517	wxPuts(_T("* Testing wxFSVolume class *"));
	3518
	3519	wxArrayString volumes = wxFSVolume::GetVolumes();
	3520	size_t count = volumes.GetCount();
	3521
	3522	if ( !count )
	3523	{
	3524	wxPuts(_T("ERROR: no mounted volumes?"));
	3525	return;
	3526	}
	3527
	3528	wxPrintf(_T("%u mounted volumes found:\n"), count);
	3529
	3530	for ( size_t n = 0; n < count; n++ )
	3531	{
	3532	wxFSVolume vol(volumes[n]);
	3533	if ( !vol.IsOk() )
	3534	{
	3535	wxPuts(_T("ERROR: couldn't create volume"));
	3536	continue;
	3537	}
	3538
	3539	wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
	3540	n + 1,
	3541	vol.GetDisplayName().c_str(),
	3542	vol.GetName().c_str(),
	3543	volumeKinds[vol.GetKind()],
	3544	vol.IsWritable() ? _T("rw") : _T("ro"),
	3545	vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
	3546	: _T("fixed"));
	3547	}
	3548	}
	3549
	3550	#endif // TEST_VOLUME
	3551
	3552	// ----------------------------------------------------------------------------
	3553	// wide char and Unicode support
	3554	// ----------------------------------------------------------------------------
	3555
	3556	#ifdef TEST_WCHAR
	3557
	3558	#include "wx/strconv.h"
	3559	#include "wx/fontenc.h"
	3560	#include "wx/encconv.h"
	3561	#include "wx/buffer.h"
	3562
	3563	static const unsigned char utf8koi8r[] =
	3564	{
	3565	208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
	3566	208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
	3567	176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
	3568	208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
	3569	181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
	3570	208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
	3571	178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
	3572	};
	3573
	3574	static const unsigned char utf8iso8859_1[] =
	3575	{
	3576	0x53, 0x79, 0x73, 0x74, 0xc3, 0xa8, 0x6d, 0x65, 0x73, 0x20, 0x49, 0x6e,
	3577	0x74, 0xc3, 0xa9, 0x67, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x65,
	3578	0x6e, 0x20, 0x4d, 0xc3, 0xa9, 0x63, 0x61, 0x6e, 0x69, 0x71, 0x75, 0x65,
	3579	0x20, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x71, 0x75, 0x65, 0x20, 0x65,
	3580	0x74, 0x20, 0x51, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0
	3581	};
	3582
	3583	static const unsigned char utf8Invalid[] =
	3584	{
	3585	0x3c, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x3e, 0x32, 0x30, 0x30,
	3586	0x32, 0xe5, 0xb9, 0xb4, 0x30, 0x39, 0xe6, 0x9c, 0x88, 0x32, 0x35, 0xe6,
	3587	0x97, 0xa5, 0x20, 0x30, 0x37, 0xe6, 0x99, 0x82, 0x33, 0x39, 0xe5, 0x88,
	3588	0x86, 0x35, 0x37, 0xe7, 0xa7, 0x92, 0x3c, 0x2f, 0x64, 0x69, 0x73, 0x70,
	3589	0x6c, 0x61, 0x79, 0
	3590	};
	3591
	3592	static const struct Utf8Data
	3593	{
	3594	const unsigned char *text;
	3595	size_t len;
	3596	const wxChar *charset;
	3597	wxFontEncoding encoding;
	3598	} utf8data[] =
	3599	{
	3600	{ utf8Invalid, WXSIZEOF(utf8Invalid), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
	3601	{ utf8koi8r, WXSIZEOF(utf8koi8r), _T("koi8-r"), wxFONTENCODING_KOI8 },
	3602	{ utf8iso8859_1, WXSIZEOF(utf8iso8859_1), _T("iso8859-1"), wxFONTENCODING_ISO8859_1 },
	3603	};
	3604
	3605	static void TestUtf8()
	3606	{
	3607	wxPuts(_T("* Testing UTF8 support *\n"));
	3608
	3609	char buf[1024];
	3610	wchar_t wbuf[1024];
	3611
	3612	for ( size_t n = 0; n < WXSIZEOF(utf8data); n++ )
	3613	{
	3614	const Utf8Data& u8d = utf8data[n];
	3615	if ( wxConvUTF8.MB2WC(wbuf, (const char *)u8d.text,
	3616	WXSIZEOF(wbuf)) == (size_t)-1 )
	3617	{
	3618	wxPuts(_T("ERROR: UTF-8 decoding failed."));
	3619	}
	3620	else
	3621	{
	3622	wxCSConv conv(u8d.charset);
	3623	if ( conv.WC2MB(buf, wbuf, WXSIZEOF(buf)) == (size_t)-1 )
	3624	{
	3625	wxPrintf(_T("ERROR: conversion to %s failed.\n"), u8d.charset);
	3626	}
	3627	else
	3628	{
	3629	wxPrintf(_T("String in %s: %s\n"), u8d.charset, buf);
	3630	}
	3631	}
	3632
	3633	wxString s(wxConvUTF8.cMB2WC((const char *)u8d.text));
	3634	if ( s.empty() )
	3635	s = _T("<< conversion failed >>");
	3636	wxPrintf(_T("String in current cset: %s\n"), s.c_str());
	3637
	3638	}
	3639
	3640	wxPuts(wxEmptyString);
	3641	}
	3642
	3643	static void TestEncodingConverter()
	3644	{
	3645	wxPuts(_T("* Testing wxEncodingConverter *\n"));
	3646
	3647	// using wxEncodingConverter should give the same result as above
	3648	char buf[1024];
	3649	wchar_t wbuf[1024];
	3650	if ( wxConvUTF8.MB2WC(wbuf, (const char *)utf8koi8r,
	3651	WXSIZEOF(utf8koi8r)) == (size_t)-1 )
	3652	{
	3653	wxPuts(_T("ERROR: UTF-8 decoding failed."));
	3654	}
	3655	else
	3656	{
	3657	wxEncodingConverter ec;
	3658	ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
	3659	ec.Convert(wbuf, buf);
	3660	wxPrintf(_T("The same KOI8-R string using wxEC: %s\n"), buf);
	3661	}
	3662
	3663	wxPuts(wxEmptyString);
	3664	}
	3665
	3666	#endif // TEST_WCHAR
	3667
	3668	// ----------------------------------------------------------------------------
	3669	// ZIP stream
	3670	// ----------------------------------------------------------------------------
	3671
	3672	#ifdef TEST_ZIP
	3673
	3674	#include "wx/filesys.h"
	3675	#include "wx/fs_zip.h"
	3676	#include "wx/zipstrm.h"
	3677
	3678	static const wxChar *TESTFILE_ZIP = _T("testdata.zip");
	3679
	3680	static void TestZipStreamRead()
	3681	{
	3682	wxPuts(_T("* Testing ZIP reading *\n"));
	3683
	3684	static const wxString filename = _T("foo");
	3685	wxZipInputStream istr(TESTFILE_ZIP, filename);
	3686	wxPrintf(_T("Archive size: %u\n"), istr.GetSize());
	3687
	3688	wxPrintf(_T("Dumping the file '%s':\n"), filename.c_str());
	3689	while ( !istr.Eof() )
	3690	{
	3691	wxPutchar(istr.GetC());
	3692	fflush(stdout);
	3693	}
	3694
	3695	wxPuts(_T("\n----- done ------"));
	3696	}
	3697
	3698	static void DumpZipDirectory(wxFileSystem& fs,
	3699	const wxString& dir,
	3700	const wxString& indent)
	3701	{
	3702	wxString prefix = wxString::Format(_T("%s#zip:%s"),
	3703	TESTFILE_ZIP, dir.c_str());
	3704	wxString wildcard = prefix + _T("/*");
	3705
	3706	wxString dirname = fs.FindFirst(wildcard, wxDIR);
	3707	while ( !dirname.empty() )
	3708	{
	3709	if ( !dirname.StartsWith(prefix + _T('/'), &dirname) )
	3710	{
	3711	wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
	3712
	3713	break;
	3714	}
	3715
	3716	wxPrintf(_T("%s%s\n"), indent.c_str(), dirname.c_str());
	3717
	3718	DumpZipDirectory(fs, dirname,
	3719	indent + wxString(_T(' '), 4));
	3720
	3721	dirname = fs.FindNext();
	3722	}
	3723
	3724	wxString filename = fs.FindFirst(wildcard, wxFILE);
	3725	while ( !filename.empty() )
	3726	{
	3727	if ( !filename.StartsWith(prefix, &filename) )
	3728	{
	3729	wxPrintf(_T("ERROR: unexpected wxFileSystem::FindNext result\n"));
	3730
	3731	break;
	3732	}
	3733
	3734	wxPrintf(_T("%s%s\n"), indent.c_str(), filename.c_str());
	3735
	3736	filename = fs.FindNext();
	3737	}
	3738	}
	3739
	3740	static void TestZipFileSystem()
	3741	{
	3742	wxPuts(_T("* Testing ZIP file system *\n"));
	3743
	3744	wxFileSystem::AddHandler(new wxZipFSHandler);
	3745	wxFileSystem fs;
	3746	wxPrintf(_T("Dumping all files in the archive %s:\n"), TESTFILE_ZIP);
	3747
	3748	DumpZipDirectory(fs, _T(""), wxString(_T(' '), 4));
	3749	}
	3750
	3751	#endif // TEST_ZIP
	3752
	3753	// ----------------------------------------------------------------------------
	3754	// date time
	3755	// ----------------------------------------------------------------------------
	3756
	3757	#ifdef TEST_DATETIME
	3758
	3759	#include <math.h>
	3760
	3761	#include "wx/datetime.h"
	3762
	3763	// this test miscellaneous static wxDateTime functions
	3764	static void TestTimeStatic()
	3765	{
	3766	wxPuts(_T("\n* wxDateTime static methods test *"));
	3767
	3768	// some info about the current date
	3769	int year = wxDateTime::GetCurrentYear();
	3770	wxPrintf(_T("Current year %d is %sa leap one and has %d days.\n"),
	3771	year,
	3772	wxDateTime::IsLeapYear(year) ? "" : "not ",
	3773	wxDateTime::GetNumberOfDays(year));
	3774
	3775	wxDateTime::Month month = wxDateTime::GetCurrentMonth();
	3776	wxPrintf(_T("Current month is '%s' ('%s') and it has %d days\n"),
	3777	wxDateTime::GetMonthName(month, wxDateTime::Name_Abbr).c_str(),
	3778	wxDateTime::GetMonthName(month).c_str(),
	3779	wxDateTime::GetNumberOfDays(month));
	3780	}
	3781
	3782	// test time zones stuff
	3783	static void TestTimeZones()
	3784	{
	3785	wxPuts(_T("\n* wxDateTime timezone test *"));
	3786
	3787	wxDateTime now = wxDateTime::Now();
	3788
	3789	wxPrintf(_T("Current GMT time:\t%s\n"), now.Format(_T("%c"), wxDateTime::GMT0).c_str());
	3790	wxPrintf(_T("Unix epoch (GMT):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::GMT0).c_str());
	3791	wxPrintf(_T("Unix epoch (EST):\t%s\n"), wxDateTime((time_t)0).Format(_T("%c"), wxDateTime::EST).c_str());
	3792	wxPrintf(_T("Current time in Paris:\t%s\n"), now.Format(_T("%c"), wxDateTime::CET).c_str());
	3793	wxPrintf(_T(" Moscow:\t%s\n"), now.Format(_T("%c"), wxDateTime::MSK).c_str());
	3794	wxPrintf(_T(" New York:\t%s\n"), now.Format(_T("%c"), wxDateTime::EST).c_str());
	3795
	3796	wxPrintf(_T("%s\n"), wxDateTime::Now().Format(_T("Our timezone is %Z")).c_str());
	3797
	3798	wxDateTime::Tm tm = now.GetTm();
	3799	if ( wxDateTime(tm) != now )
	3800	{
	3801	wxPrintf(_T("ERROR: got %s instead of %s\n"),
	3802	wxDateTime(tm).Format().c_str(), now.Format().c_str());
	3803	}
	3804	}
	3805
	3806	// test some minimal support for the dates outside the standard range
	3807	static void TestTimeRange()
	3808	{
	3809	wxPuts(_T("\n* wxDateTime out-of-standard-range dates test *"));
	3810
	3811	static const wxChar *fmt = _T("%d-%b-%Y %H:%M:%S");
	3812
	3813	wxPrintf(_T("Unix epoch:\t%s\n"),
	3814	wxDateTime(2440587.5).Format(fmt).c_str());
	3815	wxPrintf(_T("Feb 29, 0: \t%s\n"),
	3816	wxDateTime(29, wxDateTime::Feb, 0).Format(fmt).c_str());
	3817	wxPrintf(_T("JDN 0: \t%s\n"),
	3818	wxDateTime(0.0).Format(fmt).c_str());
	3819	wxPrintf(_T("Jan 1, 1AD:\t%s\n"),
	3820	wxDateTime(1, wxDateTime::Jan, 1).Format(fmt).c_str());
	3821	wxPrintf(_T("May 29, 2099:\t%s\n"),
	3822	wxDateTime(29, wxDateTime::May, 2099).Format(fmt).c_str());
	3823	}
	3824
	3825	// test DST calculations
	3826	static void TestTimeDST()
	3827	{
	3828	wxPuts(_T("\n* wxDateTime DST test *"));
	3829
	3830	wxPrintf(_T("DST is%s in effect now.\n\n"),
	3831	wxDateTime::Now().IsDST() ? wxEmptyString : _T(" not"));
	3832
	3833	for ( int year = 1990; year < 2005; year++ )
	3834	{
	3835	wxPrintf(_T("DST period in Europe for year %d: from %s to %s\n"),
	3836	year,
	3837	wxDateTime::GetBeginDST(year, wxDateTime::Country_EEC).Format().c_str(),
	3838	wxDateTime::GetEndDST(year, wxDateTime::Country_EEC).Format().c_str());
	3839	}
	3840	}
	3841
	3842	static void TestDateTimeInteractive()
	3843	{
	3844	wxPuts(_T("\n* interactive wxDateTime tests *"));
	3845
	3846	wxChar buf[128];
	3847
	3848	for ( ;; )
	3849	{
	3850	wxPrintf(_T("Enter a date: "));
	3851	if ( !wxFgets(buf, WXSIZEOF(buf), stdin) )
	3852	break;
	3853
	3854	// kill the last '\n'
	3855	buf[wxStrlen(buf) - 1] = 0;
	3856
	3857	wxDateTime dt;
	3858	const wxChar *p = dt.ParseDate(buf);
	3859	if ( !p )
	3860	{
	3861	wxPrintf(_T("ERROR: failed to parse the date '%s'.\n"), buf);
	3862
	3863	continue;
	3864	}
	3865	else if ( *p )
	3866	{
	3867	wxPrintf(_T("WARNING: parsed only first %u characters.\n"), p - buf);
	3868	}
	3869
	3870	wxPrintf(_T("%s: day %u, week of month %u/%u, week of year %u\n"),
	3871	dt.Format(_T("%b %d, %Y")).c_str(),
	3872	dt.GetDayOfYear(),
	3873	dt.GetWeekOfMonth(wxDateTime::Monday_First),
	3874	dt.GetWeekOfMonth(wxDateTime::Sunday_First),
	3875	dt.GetWeekOfYear(wxDateTime::Monday_First));
	3876	}
	3877
	3878	wxPuts(_T("\n* done *"));
	3879	}
	3880
	3881	static void TestTimeMS()
	3882	{
	3883	wxPuts(_T("* testing millisecond-resolution support in wxDateTime *"));
	3884
	3885	wxDateTime dt1 = wxDateTime::Now(),
	3886	dt2 = wxDateTime::UNow();
	3887
	3888	wxPrintf(_T("Now = %s\n"), dt1.Format(_T("%H:%M:%S:%l")).c_str());
	3889	wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
	3890	wxPrintf(_T("Dummy loop: "));
	3891	for ( int i = 0; i < 6000; i++ )
	3892	{
	3893	//for ( int j = 0; j < 10; j++ )
	3894	{
	3895	wxString s;
	3896	s.Printf(_T("%g"), sqrt((float)i));
	3897	}
	3898
	3899	if ( !(i % 100) )
	3900	wxPutchar('.');
	3901	}
	3902	wxPuts(_T(", done"));
	3903
	3904	dt1 = dt2;
	3905	dt2 = wxDateTime::UNow();
	3906	wxPrintf(_T("UNow = %s\n"), dt2.Format(_T("%H:%M:%S:%l")).c_str());
	3907
	3908	wxPrintf(_T("Loop executed in %s ms\n"), (dt2 - dt1).Format(_T("%l")).c_str());
	3909
	3910	wxPuts(_T("\n* done *"));
	3911	}
	3912
	3913	static void TestTimeHolidays()
	3914	{
	3915	wxPuts(_T("\n* testing wxDateTimeHolidayAuthority *\n"));
	3916
	3917	wxDateTime::Tm tm = wxDateTime(29, wxDateTime::May, 2000).GetTm();
	3918	wxDateTime dtStart(1, tm.mon, tm.year),
	3919	dtEnd = dtStart.GetLastMonthDay();
	3920
	3921	wxDateTimeArray hol;
	3922	wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol);
	3923
	3924	const wxChar *format = _T("%d-%b-%Y (%a)");
	3925
	3926	wxPrintf(_T("All holidays between %s and %s:\n"),
	3927	dtStart.Format(format).c_str(), dtEnd.Format(format).c_str());
	3928
	3929	size_t count = hol.GetCount();
	3930	for ( size_t n = 0; n < count; n++ )
	3931	{
	3932	wxPrintf(_T("\t%s\n"), hol[n].Format(format).c_str());
	3933	}
	3934
	3935	wxPuts(wxEmptyString);
	3936	}
	3937
	3938	static void TestTimeZoneBug()
	3939	{
	3940	wxPuts(_T("\n* testing for DST/timezone bug *\n"));
	3941
	3942	wxDateTime date = wxDateTime(1, wxDateTime::Mar, 2000);
	3943	for ( int i = 0; i < 31; i++ )
	3944	{
	3945	wxPrintf(_T("Date %s: week day %s.\n"),
	3946	date.Format(_T("%d-%m-%Y")).c_str(),
	3947	date.GetWeekDayName(date.GetWeekDay()).c_str());
	3948
	3949	date += wxDateSpan::Day();
	3950	}
	3951
	3952	wxPuts(wxEmptyString);
	3953	}
	3954
	3955	static void TestTimeSpanFormat()
	3956	{
	3957	wxPuts(_T("\n* wxTimeSpan tests *"));
	3958
	3959	static const wxChar *formats[] =
	3960	{
	3961	_T("(default) %H:%M:%S"),
	3962	_T("%E weeks and %D days"),
	3963	_T("%l milliseconds"),
	3964	_T("(with ms) %H:%M:%S:%l"),
	3965	_T("100%% of minutes is %M"), // test "%%"
	3966	_T("%D days and %H hours"),
	3967	_T("or also %S seconds"),
	3968	};
	3969
	3970	wxTimeSpan ts1(1, 2, 3, 4),
	3971	ts2(111, 222, 333);
	3972	for ( size_t n = 0; n < WXSIZEOF(formats); n++ )
	3973	{
	3974	wxPrintf(_T("ts1 = %s\tts2 = %s\n"),
	3975	ts1.Format(formats[n]).c_str(),
	3976	ts2.Format(formats[n]).c_str());
	3977	}
	3978
	3979	wxPuts(wxEmptyString);
	3980	}
	3981
	3982	#endif // TEST_DATETIME
	3983
	3984	// ----------------------------------------------------------------------------
	3985	// wxTextInput/OutputStream
	3986	// ----------------------------------------------------------------------------
	3987
	3988	#ifdef TEST_TEXTSTREAM
	3989
	3990	#include "wx/txtstrm.h"
	3991	#include "wx/wfstream.h"
	3992
	3993	static void TestTextInputStream()
	3994	{
	3995	wxPuts(_T("\n* wxTextInputStream test *"));
	3996
	3997	wxString filename = _T("testdata.fc");
	3998	wxFileInputStream fsIn(filename);
	3999	if ( !fsIn.Ok() )
	4000	{
	4001	wxPuts(_T("ERROR: couldn't open file."));
	4002	}
	4003	else
	4004	{
	4005	wxTextInputStream tis(fsIn);
	4006
	4007	size_t line = 1;
	4008	for ( ;; )
	4009	{
	4010	const wxString s = tis.ReadLine();
	4011
	4012	// line could be non empty if the last line of the file isn't
	4013	// terminated with EOL
	4014	if ( fsIn.Eof() && s.empty() )
	4015	break;
	4016
	4017	wxPrintf(_T("Line %d: %s\n"), line++, s.c_str());
	4018	}
	4019	}
	4020	}
	4021
	4022	#endif // TEST_TEXTSTREAM
	4023
	4024	// ----------------------------------------------------------------------------
	4025	// threads
	4026	// ----------------------------------------------------------------------------
	4027
	4028	#ifdef TEST_THREADS
	4029
	4030	#include "wx/thread.h"
	4031
	4032	static size_t gs_counter = (size_t)-1;
	4033	static wxCriticalSection gs_critsect;
	4034	static wxSemaphore gs_cond;
	4035
	4036	class MyJoinableThread : public wxThread
	4037	{
	4038	public:
	4039	MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
	4040	{ m_n = n; Create(); }
	4041
	4042	// thread execution starts here
	4043	virtual ExitCode Entry();
	4044
	4045	private:
	4046	size_t m_n;
	4047	};
	4048
	4049	wxThread::ExitCode MyJoinableThread::Entry()
	4050	{
	4051	unsigned long res = 1;
	4052	for ( size_t n = 1; n < m_n; n++ )
	4053	{
	4054	res *= n;
	4055
	4056	// it's a loooong calculation :-)
	4057	Sleep(100);
	4058	}
	4059
	4060	return (ExitCode)res;
	4061	}
	4062
	4063	class MyDetachedThread : public wxThread
	4064	{
	4065	public:
	4066	MyDetachedThread(size_t n, wxChar ch)
	4067	{
	4068	m_n = n;
	4069	m_ch = ch;
	4070	m_cancelled = false;
	4071
	4072	Create();
	4073	}
	4074
	4075	// thread execution starts here
	4076	virtual ExitCode Entry();
	4077
	4078	// and stops here
	4079	virtual void OnExit();
	4080
	4081	private:
	4082	size_t m_n; // number of characters to write
	4083	wxChar m_ch; // character to write
	4084
	4085	bool m_cancelled; // false if we exit normally
	4086	};
	4087
	4088	wxThread::ExitCode MyDetachedThread::Entry()
	4089	{
	4090	{
	4091	wxCriticalSectionLocker lock(gs_critsect);
	4092	if ( gs_counter == (size_t)-1 )
	4093	gs_counter = 1;
	4094	else
	4095	gs_counter++;
	4096	}
	4097
	4098	for ( size_t n = 0; n < m_n; n++ )
	4099	{
	4100	if ( TestDestroy() )
	4101	{
	4102	m_cancelled = true;
	4103
	4104	break;
	4105	}
	4106
	4107	wxPutchar(m_ch);
	4108	fflush(stdout);
	4109
	4110	wxThread::Sleep(100);
	4111	}
	4112
	4113	return 0;
	4114	}
	4115
	4116	void MyDetachedThread::OnExit()
	4117	{
	4118	wxLogTrace(_T("thread"), _T("Thread %ld is in OnExit"), GetId());
	4119
	4120	wxCriticalSectionLocker lock(gs_critsect);
	4121	if ( !--gs_counter && !m_cancelled )
	4122	gs_cond.Post();
	4123	}
	4124
	4125	static void TestDetachedThreads()
	4126	{
	4127	wxPuts(_T("\n* Testing detached threads *"));
	4128
	4129	static const size_t nThreads = 3;
	4130	MyDetachedThread *threads[nThreads];
	4131	size_t n;
	4132	for ( n = 0; n < nThreads; n++ )
	4133	{
	4134	threads[n] = new MyDetachedThread(10, 'A' + n);
	4135	}
	4136
	4137	threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
	4138	threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
	4139
	4140	for ( n = 0; n < nThreads; n++ )
	4141	{
	4142	threads[n]->Run();
	4143	}
	4144
	4145	// wait until all threads terminate
	4146	gs_cond.Wait();
	4147
	4148	wxPuts(wxEmptyString);
	4149	}
	4150
	4151	static void TestJoinableThreads()
	4152	{
	4153	wxPuts(_T("\n* Testing a joinable thread (a loooong calculation...) *"));
	4154
	4155	// calc 10! in the background
	4156	MyJoinableThread thread(10);
	4157	thread.Run();
	4158
	4159	wxPrintf(_T("\nThread terminated with exit code %lu.\n"),
	4160	(unsigned long)thread.Wait());
	4161	}
	4162
	4163	static void TestThreadSuspend()
	4164	{
	4165	wxPuts(_T("\n* Testing thread suspend/resume functions *"));
	4166
	4167	MyDetachedThread *thread = new MyDetachedThread(15, 'X');
	4168
	4169	thread->Run();
	4170
	4171	// this is for this demo only, in a real life program we'd use another
	4172	// condition variable which would be signaled from wxThread::Entry() to
	4173	// tell us that the thread really started running - but here just wait a
	4174	// bit and hope that it will be enough (the problem is, of course, that
	4175	// the thread might still not run when we call Pause() which will result
	4176	// in an error)
	4177	wxThread::Sleep(300);
	4178
	4179	for ( size_t n = 0; n < 3; n++ )
	4180	{
	4181	thread->Pause();
	4182
	4183	wxPuts(_T("\nThread suspended"));
	4184	if ( n > 0 )
	4185	{
	4186	// don't sleep but resume immediately the first time
	4187	wxThread::Sleep(300);
	4188	}
	4189	wxPuts(_T("Going to resume the thread"));
	4190
	4191	thread->Resume();
	4192	}
	4193
	4194	wxPuts(_T("Waiting until it terminates now"));
	4195
	4196	// wait until the thread terminates
	4197	gs_cond.Wait();
	4198
	4199	wxPuts(wxEmptyString);
	4200	}
	4201
	4202	static void TestThreadDelete()
	4203	{
	4204	// As above, using Sleep() is only for testing here - we must use some
	4205	// synchronisation object instead to ensure that the thread is still
	4206	// running when we delete it - deleting a detached thread which already
	4207	// terminated will lead to a crash!
	4208
	4209	wxPuts(_T("\n* Testing thread delete function *"));
	4210
	4211	MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
	4212
	4213	thread0->Delete();
	4214
	4215	wxPuts(_T("\nDeleted a thread which didn't start to run yet."));
	4216
	4217	MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
	4218
	4219	thread1->Run();
	4220
	4221	wxThread::Sleep(300);
	4222
	4223	thread1->Delete();
	4224
	4225	wxPuts(_T("\nDeleted a running thread."));
	4226
	4227	MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
	4228
	4229	thread2->Run();
	4230
	4231	wxThread::Sleep(300);
	4232
	4233	thread2->Pause();
	4234
	4235	thread2->Delete();
	4236
	4237	wxPuts(_T("\nDeleted a sleeping thread."));
	4238
	4239	MyJoinableThread thread3(20);
	4240	thread3.Run();
	4241
	4242	thread3.Delete();
	4243
	4244	wxPuts(_T("\nDeleted a joinable thread."));
	4245
	4246	MyJoinableThread thread4(2);
	4247	thread4.Run();
	4248
	4249	wxThread::Sleep(300);
	4250
	4251	thread4.Delete();
	4252
	4253	wxPuts(_T("\nDeleted a joinable thread which already terminated."));
	4254
	4255	wxPuts(wxEmptyString);
	4256	}
	4257
	4258	class MyWaitingThread : public wxThread
	4259	{
	4260	public:
	4261	MyWaitingThread( wxMutex mutex, wxCondition condition )
	4262	{
	4263	m_mutex = mutex;
	4264	m_condition = condition;
	4265
	4266	Create();
	4267	}
	4268
	4269	virtual ExitCode Entry()
	4270	{
	4271	wxPrintf(_T("Thread %lu has started running.\n"), GetId());
	4272	fflush(stdout);
	4273
	4274	gs_cond.Post();
	4275
	4276	wxPrintf(_T("Thread %lu starts to wait...\n"), GetId());
	4277	fflush(stdout);
	4278
	4279	m_mutex->Lock();
	4280	m_condition->Wait();
	4281	m_mutex->Unlock();
	4282
	4283	wxPrintf(_T("Thread %lu finished to wait, exiting.\n"), GetId());
	4284	fflush(stdout);
	4285
	4286	return 0;
	4287	}
	4288
	4289	private:
	4290	wxMutex *m_mutex;
	4291	wxCondition *m_condition;
	4292	};
	4293
	4294	static void TestThreadConditions()
	4295	{
	4296	wxMutex mutex;
	4297	wxCondition condition(mutex);
	4298
	4299	// otherwise its difficult to understand which log messages pertain to
	4300	// which condition
	4301	//wxLogTrace(_T("thread"), _T("Local condition var is %08x, gs_cond = %08x"),
	4302	// condition.GetId(), gs_cond.GetId());
	4303
	4304	// create and launch threads
	4305	MyWaitingThread *threads[10];
	4306
	4307	size_t n;
	4308	for ( n = 0; n < WXSIZEOF(threads); n++ )
	4309	{
	4310	threads[n] = new MyWaitingThread( &mutex, &condition );
	4311	}
	4312
	4313	for ( n = 0; n < WXSIZEOF(threads); n++ )
	4314	{
	4315	threads[n]->Run();
	4316	}
	4317
	4318	// wait until all threads run
	4319	wxPuts(_T("Main thread is waiting for the other threads to start"));
	4320	fflush(stdout);
	4321
	4322	size_t nRunning = 0;
	4323	while ( nRunning < WXSIZEOF(threads) )
	4324	{
	4325	gs_cond.Wait();
	4326
	4327	nRunning++;
	4328
	4329	wxPrintf(_T("Main thread: %u already running\n"), nRunning);
	4330	fflush(stdout);
	4331	}
	4332
	4333	wxPuts(_T("Main thread: all threads started up."));
	4334	fflush(stdout);
	4335
	4336	wxThread::Sleep(500);
	4337
	4338	#if 1
	4339	// now wake one of them up
	4340	wxPrintf(_T("Main thread: about to signal the condition.\n"));
	4341	fflush(stdout);
	4342	condition.Signal();
	4343	#endif
	4344
	4345	wxThread::Sleep(200);
	4346
	4347	// wake all the (remaining) threads up, so that they can exit
	4348	wxPrintf(_T("Main thread: about to broadcast the condition.\n"));
	4349	fflush(stdout);
	4350	condition.Broadcast();
	4351
	4352	// give them time to terminate (dirty!)
	4353	wxThread::Sleep(500);
	4354	}
	4355
	4356	#include "wx/utils.h"
	4357
	4358	class MyExecThread : public wxThread
	4359	{
	4360	public:
	4361	MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
	4362	m_command(command)
	4363	{
	4364	Create();
	4365	}
	4366
	4367	virtual ExitCode Entry()
	4368	{
	4369	return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
	4370	}
	4371
	4372	private:
	4373	wxString m_command;
	4374	};
	4375
	4376	static void TestThreadExec()
	4377	{
	4378	wxPuts(_T("* Testing wxExecute interaction with threads *\n"));
	4379
	4380	MyExecThread thread(_T("true"));
	4381	thread.Run();
	4382
	4383	wxPrintf(_T("Main program exit code: %ld.\n"),
	4384	wxExecute(_T("false"), wxEXEC_SYNC));
	4385
	4386	wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
	4387	}
	4388
	4389	// semaphore tests
	4390	#include "wx/datetime.h"
	4391
	4392	class MySemaphoreThread : public wxThread
	4393	{
	4394	public:
	4395	MySemaphoreThread(int i, wxSemaphore *sem)
	4396	: wxThread(wxTHREAD_JOINABLE),
	4397	m_sem(sem),
	4398	m_i(i)
	4399	{
	4400	Create();
	4401	}
	4402
	4403	virtual ExitCode Entry()
	4404	{
	4405	wxPrintf(_T("%s: Thread #%d (%ld) starting to wait for semaphore...\n"),
	4406	wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
	4407
	4408	m_sem->Wait();
	4409
	4410	wxPrintf(_T("%s: Thread #%d (%ld) acquired the semaphore.\n"),
	4411	wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
	4412
	4413	Sleep(1000);
	4414
	4415	wxPrintf(_T("%s: Thread #%d (%ld) releasing the semaphore.\n"),
	4416	wxDateTime::Now().FormatTime().c_str(), m_i, (long)GetId());
	4417
	4418	m_sem->Post();
	4419
	4420	return 0;
	4421	}
	4422
	4423	private:
	4424	wxSemaphore *m_sem;
	4425	int m_i;
	4426	};
	4427
	4428	WX_DEFINE_ARRAY_PTR(wxThread *, ArrayThreads);
	4429
	4430	static void TestSemaphore()
	4431	{
	4432	wxPuts(_T("* Testing wxSemaphore class. *"));
	4433
	4434	static const int SEM_LIMIT = 3;
	4435
	4436	wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
	4437	ArrayThreads threads;
	4438
	4439	for ( int i = 0; i < 3*SEM_LIMIT; i++ )
	4440	{
	4441	threads.Add(new MySemaphoreThread(i, &sem));
	4442	threads.Last()->Run();
	4443	}
	4444
	4445	for ( size_t n = 0; n < threads.GetCount(); n++ )
	4446	{
	4447	threads[n]->Wait();
	4448	delete threads[n];
	4449	}
	4450	}
	4451
	4452	#endif // TEST_THREADS
	4453
	4454	// ----------------------------------------------------------------------------
	4455	// entry point
	4456	// ----------------------------------------------------------------------------
	4457
	4458	#ifdef TEST_SNGLINST
	4459	#include "wx/snglinst.h"
	4460	#endif // TEST_SNGLINST
	4461
	4462	int main(int argc, char **argv)
	4463	{
	4464	wxApp::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, "program");
	4465
	4466	wxInitializer initializer;
	4467	if ( !initializer )
	4468	{
	4469	fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
	4470
	4471	return -1;
	4472	}
	4473
	4474	#ifdef TEST_SNGLINST
	4475	wxSingleInstanceChecker checker;
	4476	if ( checker.Create(_T(".wxconsole.lock")) )
	4477	{
	4478	if ( checker.IsAnotherRunning() )
	4479	{
	4480	wxPrintf(_T("Another instance of the program is running, exiting.\n"));
	4481
	4482	return 1;
	4483	}
	4484
	4485	// wait some time to give time to launch another instance
	4486	wxPrintf(_T("Press \"Enter\" to continue..."));
	4487	wxFgetc(stdin);
	4488	}
	4489	else // failed to create
	4490	{
	4491	wxPrintf(_T("Failed to init wxSingleInstanceChecker.\n"));
	4492	}
	4493	#endif // TEST_SNGLINST
	4494
	4495	#ifdef TEST_CMDLINE
	4496	TestCmdLineConvert();
	4497
	4498	#if wxUSE_CMDLINE_PARSER
	4499	static const wxCmdLineEntryDesc cmdLineDesc[] =
	4500	{
	4501	{ wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("show this help message"),
	4502	wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP },
	4503	{ wxCMD_LINE_SWITCH, _T("v"), _T("verbose"), _T("be verbose") },
	4504	{ wxCMD_LINE_SWITCH, _T("q"), _T("quiet"), _T("be quiet") },
	4505
	4506	{ wxCMD_LINE_OPTION, _T("o"), _T("output"), _T("output file") },
	4507	{ wxCMD_LINE_OPTION, _T("i"), _T("input"), _T("input dir") },
	4508	{ wxCMD_LINE_OPTION, _T("s"), _T("size"), _T("output block size"),
	4509	wxCMD_LINE_VAL_NUMBER },
	4510	{ wxCMD_LINE_OPTION, _T("d"), _T("date"), _T("output file date"),
	4511	wxCMD_LINE_VAL_DATE },
	4512
	4513	{ wxCMD_LINE_PARAM, NULL, NULL, _T("input file"),
	4514	wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
	4515
	4516	{ wxCMD_LINE_NONE }
	4517	};
	4518
	4519	#if wxUSE_UNICODE
	4520	wxChar *wargv = new wxChar [argc + 1];
	4521
	4522	{
	4523	int n;
	4524
	4525	for (n = 0; n < argc; n++ )
	4526	{
	4527	wxMB2WXbuf warg = wxConvertMB2WX(argv[n]);
	4528	wargv[n] = wxStrdup(warg);
	4529	}
	4530
	4531	wargv[n] = NULL;
	4532	}
	4533
	4534	#define argv wargv
	4535	#endif // wxUSE_UNICODE
	4536
	4537	wxCmdLineParser parser(cmdLineDesc, argc, argv);
	4538
	4539	#if wxUSE_UNICODE
	4540	{
	4541	for ( int n = 0; n < argc; n++ )
	4542	free(wargv[n]);
	4543
	4544	delete [] wargv;
	4545	}
	4546	#endif // wxUSE_UNICODE
	4547
	4548	parser.AddOption(_T("project_name"), _T(""), _T("full path to project file"),
	4549	wxCMD_LINE_VAL_STRING,
	4550	wxCMD_LINE_OPTION_MANDATORY \| wxCMD_LINE_NEEDS_SEPARATOR);
	4551
	4552	switch ( parser.Parse() )
	4553	{
	4554	case -1:
	4555	wxLogMessage(_T("Help was given, terminating."));
	4556	break;
	4557
	4558	case 0:
	4559	ShowCmdLine(parser);
	4560	break;
	4561
	4562	default:
	4563	wxLogMessage(_T("Syntax error detected, aborting."));
	4564	break;
	4565	}
	4566	#endif // wxUSE_CMDLINE_PARSER
	4567
	4568	#endif // TEST_CMDLINE
	4569
	4570	#ifdef TEST_DIR
	4571	#if TEST_ALL
	4572	TestDirExists();
	4573	TestDirEnum();
	4574	#endif
	4575	TestDirTraverse();
	4576	#endif // TEST_DIR
	4577
	4578	#ifdef TEST_DLLLOADER
	4579	TestDllLoad();
	4580	#endif // TEST_DLLLOADER
	4581
	4582	#ifdef TEST_ENVIRON
	4583	TestEnvironment();
	4584	#endif // TEST_ENVIRON
	4585
	4586	#ifdef TEST_EXECUTE
	4587	TestExecute();
	4588	#endif // TEST_EXECUTE
	4589
	4590	#ifdef TEST_FILECONF
	4591	TestFileConfRead();
	4592	#endif // TEST_FILECONF
	4593
	4594	#ifdef TEST_LIST
	4595	TestListCtor();
	4596	TestList();
	4597	#endif // TEST_LIST
	4598
	4599	#ifdef TEST_LOCALE
	4600	TestDefaultLang();
	4601	#endif // TEST_LOCALE
	4602
	4603	#ifdef TEST_LOG
	4604	wxPuts(_T("* Testing wxLog *"));
	4605
	4606	wxString s;
	4607	for ( size_t n = 0; n < 8000; n++ )
	4608	{
	4609	s << (wxChar)(_T('A') + (n % 26));
	4610	}
	4611
	4612	wxLogWarning(_T("The length of the string is %lu"),
	4613	(unsigned long)s.length());
	4614
	4615	wxString msg;
	4616	msg.Printf(_T("A very very long message: '%s', the end!\n"), s.c_str());
	4617
	4618	// this one shouldn't be truncated
	4619	wxPrintf(msg);
	4620
	4621	// but this one will because log functions use fixed size buffer
	4622	// (note that it doesn't need '\n' at the end neither - will be added
	4623	// by wxLog anyhow)
	4624	wxLogMessage(_T("A very very long message 2: '%s', the end!"), s.c_str());
	4625	#endif // TEST_LOG
	4626
	4627	#ifdef TEST_FILE
	4628	TestFileRead();
	4629	TestTextFileRead();
	4630	TestFileCopy();
	4631	#endif // TEST_FILE
	4632
	4633	#ifdef TEST_FILENAME
	4634	TestFileNameConstruction();
	4635	TestFileNameMakeRelative();
	4636	TestFileNameMakeAbsolute();
	4637	TestFileNameSplit();
	4638	TestFileNameTemp();
	4639	TestFileNameCwd();
	4640	TestFileNameDirManip();
	4641	TestFileNameComparison();
	4642	TestFileNameOperations();
	4643	#endif // TEST_FILENAME
	4644
	4645	#ifdef TEST_FILETIME
	4646	TestFileGetTimes();
	4647	#if 0
	4648	TestFileSetTimes();
	4649	#endif
	4650	#endif // TEST_FILETIME
	4651
	4652	#ifdef TEST_FTP
	4653	wxLog::AddTraceMask(FTP_TRACE_MASK);
	4654	if ( TestFtpConnect() )
	4655	{
	4656	#if TEST_ALL
	4657	TestFtpList();
	4658	TestFtpDownload();
	4659	TestFtpMisc();
	4660	TestFtpFileSize();
	4661	TestFtpUpload();
	4662	#endif
	4663
	4664	#if TEST_INTERACTIVE
	4665	TestFtpInteractive();
	4666	#endif
	4667	}
	4668	//else: connecting to the FTP server failed
	4669
	4670	#if 0
	4671	TestFtpWuFtpd();
	4672	#endif
	4673	#endif // TEST_FTP
	4674
	4675	#ifdef TEST_HASHMAP
	4676	TestHashMap();
	4677	#endif // TEST_HASHMAP
	4678
	4679	#ifdef TEST_HASHSET
	4680	TestHashSet();
	4681	#endif // TEST_HASHSET
	4682
	4683	#ifdef TEST_MIME
	4684	wxLog::AddTraceMask(_T("mime"));
	4685	#if TEST_ALL
	4686	TestMimeEnum();
	4687	TestMimeOverride();
	4688	TestMimeAssociate();
	4689	#endif
	4690	TestMimeFilename();
	4691	#endif // TEST_MIME
	4692
	4693	#ifdef TEST_INFO_FUNCTIONS
	4694	#if TEST_ALL
	4695	TestOsInfo();
	4696	TestUserInfo();
	4697
	4698	#if TEST_INTERACTIVE
	4699	TestDiskInfo();
	4700	#endif
	4701	#endif
	4702	#endif // TEST_INFO_FUNCTIONS
	4703
	4704	#ifdef TEST_PATHLIST
	4705	TestPathList();
	4706	#endif // TEST_PATHLIST
	4707
	4708	#ifdef TEST_ODBC
	4709	TestDbOpen();
	4710	#endif // TEST_ODBC
	4711
	4712	#ifdef TEST_PRINTF
	4713	TestPrintf();
	4714	#endif // TEST_PRINTF
	4715
	4716	#ifdef TEST_REGCONF
	4717	#if 0
	4718	TestRegConfWrite();
	4719	#endif
	4720	TestRegConfRead();
	4721	#endif // TEST_REGCONF
	4722
	4723	#if defined TEST_REGEX && TEST_INTERACTIVE
	4724	TestRegExInteractive();
	4725	#endif // defined TEST_REGEX && TEST_INTERACTIVE
	4726
	4727	#ifdef TEST_REGISTRY
	4728	TestRegistryRead();
	4729	TestRegistryAssociation();
	4730	#endif // TEST_REGISTRY
	4731
	4732	#ifdef TEST_SOCKETS
	4733	TestSocketServer();
	4734	TestSocketClient();
	4735	#endif // TEST_SOCKETS
	4736
	4737	#ifdef TEST_STREAMS
	4738	#if TEST_ALL
	4739	TestFileStream();
	4740	#endif
	4741	TestMemoryStream();
	4742	#endif // TEST_STREAMS
	4743
	4744	#ifdef TEST_TEXTSTREAM
	4745	TestTextInputStream();
	4746	#endif // TEST_TEXTSTREAM
	4747
	4748	#ifdef TEST_THREADS
	4749	int nCPUs = wxThread::GetCPUCount();
	4750	wxPrintf(_T("This system has %d CPUs\n"), nCPUs);
	4751	if ( nCPUs != -1 )
	4752	wxThread::SetConcurrency(nCPUs);
	4753
	4754	TestJoinableThreads();
	4755
	4756	#if TEST_ALL
	4757	TestJoinableThreads();
	4758	TestDetachedThreads();
	4759	TestThreadSuspend();
	4760	TestThreadDelete();
	4761	TestThreadConditions();
	4762	TestThreadExec();
	4763	TestSemaphore();
	4764	#endif
	4765	#endif // TEST_THREADS
	4766
	4767	#ifdef TEST_TIMER
	4768	TestStopWatch();
	4769	#endif // TEST_TIMER
	4770
	4771	#ifdef TEST_DATETIME
	4772	#if TEST_ALL
	4773	TestTimeSet();
	4774	TestTimeStatic();
	4775	TestTimeRange();
	4776	TestTimeZones();
	4777	TestTimeTicks();
	4778	TestTimeJDN();
	4779	TestTimeDST();
	4780	TestTimeWDays();
	4781	TestTimeWNumber();
	4782	TestTimeParse();
	4783	TestTimeArithmetics();
	4784	TestTimeHolidays();
	4785	TestTimeSpanFormat();
	4786	TestTimeMS();
	4787
	4788	TestTimeZoneBug();
	4789	#endif
	4790
	4791	#if TEST_INTERACTIVE
	4792	TestDateTimeInteractive();
	4793	#endif
	4794	#endif // TEST_DATETIME
	4795
	4796	#ifdef TEST_SCOPEGUARD
	4797	TestScopeGuard();
	4798	#endif
	4799
	4800	#ifdef TEST_USLEEP
	4801	wxPuts(_T("Sleeping for 3 seconds... z-z-z-z-z..."));
	4802	wxUsleep(3000);
	4803	#endif // TEST_USLEEP
	4804
	4805	#ifdef TEST_VCARD
	4806	TestVCardRead();
	4807	TestVCardWrite();
	4808	#endif // TEST_VCARD
	4809
	4810	#ifdef TEST_VOLUME
	4811	TestFSVolume();
	4812	#endif // TEST_VOLUME
	4813
	4814	#ifdef TEST_WCHAR
	4815	TestUtf8();
	4816	TestEncodingConverter();
	4817	#endif // TEST_WCHAR
	4818
	4819	#ifdef TEST_ZIP
	4820	TestZipStreamRead();
	4821	TestZipFileSystem();
	4822	#endif // TEST_ZIP
	4823
	4824	wxUnusedVar(argc);
	4825	wxUnusedVar(argv);
	4826	return 0;
	4827	}
	4828