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

... / ...

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