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