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