[wxWidgets.git] / tests / interactive / output.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/interactive/output.cpp
// Purpose:     Miscellaneous tests NOT requiring user input, just user checks
// Author:      Francesco Montorsi (extracted from console sample)
// Created:     2010-06-21
// Copyright:   (c) 2010 wxWidgets team
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/app.h"
#include "wx/wxcrt.h"           // for wxPuts
#include "wx/wxcrtvararg.h"     // for wxPrintf

// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------

#define TEST_DYNLIB
#define TEST_MIME
#define TEST_INFO_FUNCTIONS
#define TEST_STACKWALKER
#define TEST_STDPATHS
#define TEST_VOLUME

// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------

class InteractiveOutputTestCase : public CppUnit::TestCase
{
public:
    InteractiveOutputTestCase() { }

private:
    CPPUNIT_TEST_SUITE( InteractiveOutputTestCase );
        CPPUNIT_TEST( TestDllListLoaded );
        CPPUNIT_TEST( TestMimeEnum );
        CPPUNIT_TEST( TestMimeAssociate );
        CPPUNIT_TEST( TestMimeFilename );
        CPPUNIT_TEST( TestOsInfo );
        CPPUNIT_TEST( TestPlatformInfo );
        CPPUNIT_TEST( TestUserInfo );
        CPPUNIT_TEST( TestStackWalk );
        CPPUNIT_TEST( TestStandardPaths );
        CPPUNIT_TEST( TestFSVolume );
    CPPUNIT_TEST_SUITE_END();

    void TestDllListLoaded();
    void TestMimeEnum();
    void TestMimeAssociate();
    void TestMimeFilename();
    void TestOsInfo();
    void TestPlatformInfo();
    void TestUserInfo();
    void TestStackWalk();
    void TestStandardPaths();
    void TestFSVolume();

    wxDECLARE_NO_COPY_CLASS(InteractiveOutputTestCase);
};

// ----------------------------------------------------------------------------
// CppUnit macros
// ----------------------------------------------------------------------------

//CPPUNIT_TEST_SUITE_REGISTRATION( InteractiveOutputTestCase );
    // do not run this test by default!

CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( InteractiveOutputTestCase, "InteractiveOutputTestCase" );

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxDllLoader
// ----------------------------------------------------------------------------

#if !defined(__WINDOWS__) && !defined(__UNIX__)
    #undef TEST_DYNLIB
#endif

#include "wx/dynlib.h"

void InteractiveOutputTestCase::TestDllListLoaded()
{
#ifdef TEST_DYNLIB
    wxPuts(wxT("*** testing wxDynamicLibrary::ListLoaded() ***\n"));

    wxPuts("Loaded modules:");
    wxDynamicLibraryDetailsArray dlls = wxDynamicLibrary::ListLoaded();
    const size_t count = dlls.GetCount();
    for ( size_t n = 0; n < count; ++n )
    {
        const wxDynamicLibraryDetails& details = dlls[n];
        printf("%-45s", (const char *)details.GetPath().mb_str());

        void *addr wxDUMMY_INITIALIZE(NULL);
        size_t len wxDUMMY_INITIALIZE(0);
        if ( details.GetAddress(&addr, &len) )
        {
            printf(" %08lx:%08lx",
                   (unsigned long)addr, (unsigned long)((char *)addr + len));
        }

        printf(" %s\n", (const char *)details.GetVersion().mb_str());
    }

    wxPuts(wxEmptyString);
#endif // TEST_DYNLIB
}


// ----------------------------------------------------------------------------
// MIME types
// ----------------------------------------------------------------------------

#include "wx/mimetype.h"

void InteractiveOutputTestCase::TestMimeEnum()
{
#ifdef TEST_MIME
    wxPuts(wxT("*** Testing wxMimeTypesManager::EnumAllFileTypes() ***\n"));

    wxArrayString mimetypes;

    size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);

    wxPrintf(wxT("*** All %u known filetypes: ***\n"), count);

    wxArrayString exts;
    wxString desc;

    for ( size_t n = 0; n < count; n++ )
    {
        wxFileType *filetype =
            wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
        if ( !filetype )
        {
            wxPrintf(wxT("   nothing known about the filetype '%s'!\n"),
                   mimetypes[n].c_str());
            continue;
        }

        filetype->GetDescription(&desc);
        filetype->GetExtensions(exts);

        filetype->GetIcon(NULL);

        wxString extsAll;
        for ( size_t e = 0; e < exts.GetCount(); e++ )
        {
            if ( e > 0 )
                extsAll << wxT(", ");
            extsAll += exts[e];
        }

        wxPrintf(wxT("   %s: %s (%s)\n"),
               mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
    }

    wxPuts(wxEmptyString);
#endif // TEST_MIME
}

void InteractiveOutputTestCase::TestMimeFilename()
{
#ifdef TEST_MIME
    wxPuts(wxT("*** Testing MIME type from filename query ***\n"));

    static const wxChar *filenames[] =
    {
        wxT("readme.txt"),
        wxT("document.pdf"),
        wxT("image.gif"),
        wxT("picture.jpeg"),
    };

    for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
    {
        const wxString fname = filenames[n];
        wxString ext = fname.AfterLast(wxT('.'));
        wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
        if ( !ft )
        {
            wxPrintf(wxT("WARNING: extension '%s' is unknown.\n"), ext.c_str());
        }
        else
        {
            wxString desc;
            if ( !ft->GetDescription(&desc) )
                desc = wxT("<no description>");

            wxString cmd;
            if ( !ft->GetOpenCommand(&cmd,
                                     wxFileType::MessageParameters(fname, wxEmptyString)) )
                cmd = wxT("<no command available>");
            else
                cmd = wxString(wxT('"')) + cmd + wxT('"');

            wxPrintf(wxT("To open %s (%s) run:\n   %s\n"),
                     fname.c_str(), desc.c_str(), cmd.c_str());

            delete ft;
        }
    }

    wxPuts(wxEmptyString);
#endif // TEST_MIME
}

void InteractiveOutputTestCase::TestMimeAssociate()
{
#ifdef TEST_MIME
    wxPuts(wxT("*** Testing creation of filetype association ***\n"));

    wxFileTypeInfo ftInfo("application/x-xyz");
    ftInfo.SetOpenCommand("xyzview '%s'");
    ftInfo.SetDescription("XYZ File");
    ftInfo.AddExtension(".xyz");
    ftInfo.SetShortDesc(wxT("XYZFile")); // used under Win32 only

    wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
    if ( !ft )
    {
        wxPuts(wxT("ERROR: failed to create association!"));
    }
    else
    {
        // TODO: read it back
        delete ft;
    }

    wxPuts(wxEmptyString);
#endif // TEST_MIME
}


// ----------------------------------------------------------------------------
// misc information functions
// ----------------------------------------------------------------------------

#include "wx/utils.h"

void InteractiveOutputTestCase::TestOsInfo()
{
#ifdef TEST_INFO_FUNCTIONS
    wxPuts(wxT("*** Testing OS info functions ***\n"));

    int major, minor;
    wxGetOsVersion(&major, &minor);
    wxPrintf(wxT("Running under: %s, version %d.%d\n"),
            wxGetOsDescription().c_str(), major, minor);

    wxPrintf(wxT("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());

    wxPrintf(wxT("Host name is %s (%s).\n"),
           wxGetHostName().c_str(), wxGetFullHostName().c_str());

    wxPuts(wxEmptyString);
#endif // TEST_INFO_FUNCTIONS
}

void InteractiveOutputTestCase::TestPlatformInfo()
{
#ifdef TEST_INFO_FUNCTIONS
    wxPuts(wxT("*** Testing wxPlatformInfo functions ***\n"));

    // get this platform
    wxPlatformInfo plat;

    wxPrintf(wxT("Operating system family name is: %s\n"), plat.GetOperatingSystemFamilyName().c_str());
    wxPrintf(wxT("Operating system name is: %s\n"), plat.GetOperatingSystemIdName().c_str());
    wxPrintf(wxT("Port ID name is: %s\n"), plat.GetPortIdName().c_str());
    wxPrintf(wxT("Port ID short name is: %s\n"), plat.GetPortIdShortName().c_str());
    wxPrintf(wxT("Architecture is: %s\n"), plat.GetArchName().c_str());
    wxPrintf(wxT("Endianness is: %s\n"), plat.GetEndiannessName().c_str());

    wxPuts(wxEmptyString);
#endif // TEST_INFO_FUNCTIONS
}

void InteractiveOutputTestCase::TestUserInfo()
{
#ifdef TEST_INFO_FUNCTIONS
    wxPuts(wxT("*** Testing user info functions ***\n"));

    wxPrintf(wxT("User id is:\t%s\n"), wxGetUserId().c_str());
    wxPrintf(wxT("User name is:\t%s\n"), wxGetUserName().c_str());
    wxPrintf(wxT("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
    wxPrintf(wxT("Email address:\t%s\n"), wxGetEmailAddress().c_str());

    wxPuts(wxEmptyString);
#endif // TEST_INFO_FUNCTIONS
}


// ----------------------------------------------------------------------------
// stack backtrace
// ----------------------------------------------------------------------------

#if wxUSE_STACKWALKER

#include "wx/stackwalk.h"

class StackDump : public wxStackWalker
{
public:
    StackDump(const char *argv0)
        : wxStackWalker(argv0)
    {
    }

    virtual void Walk(size_t skip = 1, size_t maxdepth = wxSTACKWALKER_MAX_DEPTH)
    {
        wxPuts(wxT("Stack dump:"));

        wxStackWalker::Walk(skip, maxdepth);
    }

protected:
    virtual void OnStackFrame(const wxStackFrame& frame)
    {
        printf("[%2d] ", (int) frame.GetLevel());

        wxString name = frame.GetName();
        if ( !name.empty() )
        {
            printf("%-20.40s", (const char*)name.mb_str());
        }
        else
        {
            printf("0x%08lx", (unsigned long)frame.GetAddress());
        }

        if ( frame.HasSourceLocation() )
        {
            printf("\t%s:%d",
                   (const char*)frame.GetFileName().mb_str(),
                   (int)frame.GetLine());
        }

        puts("");

        wxString type, val;
        for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
        {
            printf("\t%s %s = %s\n", (const char*)type.mb_str(),
                                     (const char*)name.mb_str(),
                                     (const char*)val.mb_str());
        }
    }
};
#endif

void InteractiveOutputTestCase::TestStackWalk()
{
#ifdef TEST_STACKWALKER
#if wxUSE_STACKWALKER
    wxPuts(wxT("*** Testing wxStackWalker ***"));

    wxString progname(wxTheApp->argv[0]);
    StackDump dump(progname.utf8_str());
    dump.Walk();

    wxPuts("\n");
#endif
#endif // TEST_STACKWALKER
}


// ----------------------------------------------------------------------------
// standard paths
// ----------------------------------------------------------------------------

#include "wx/stdpaths.h"
#include "wx/wxchar.h"      // wxPrintf

void InteractiveOutputTestCase::TestStandardPaths()
{
#ifdef TEST_STDPATHS
    wxPuts(wxT("*** Testing wxStandardPaths ***"));

    wxTheApp->SetAppName(wxT("console"));

    wxStandardPathsBase& stdp = wxStandardPaths::Get();
    wxPrintf(wxT("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
    wxPrintf(wxT("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
    wxPrintf(wxT("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
    wxPrintf(wxT("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
    wxPrintf(wxT("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
    wxPrintf(wxT("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
    wxPrintf(wxT("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
    wxPrintf(wxT("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
    wxPrintf(wxT("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
    wxPrintf(wxT("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
    wxPrintf(wxT("Localized res. dir:\t%s\n"),
             stdp.GetLocalizedResourcesDir(wxT("fr")).c_str());
    wxPrintf(wxT("Message catalogs dir:\t%s\n"),
             stdp.GetLocalizedResourcesDir
                  (
                    wxT("fr"),
                    wxStandardPaths::ResourceCat_Messages
                  ).c_str());

    wxPuts("\n");
#endif // TEST_STDPATHS
}


// ----------------------------------------------------------------------------
// wxVolume tests
// ----------------------------------------------------------------------------

#if !defined(__WIN32__) || !wxUSE_FSVOLUME
    #undef TEST_VOLUME
#endif

#ifdef TEST_VOLUME

#include "wx/volume.h"
static const wxChar *volumeKinds[] =
{
    wxT("floppy"),
    wxT("hard disk"),
    wxT("CD-ROM"),
    wxT("DVD-ROM"),
    wxT("network volume"),
    wxT("other volume"),
};

#endif

void InteractiveOutputTestCase::TestFSVolume()
{
#ifdef TEST_VOLUME
    wxPuts(wxT("*** Testing wxFSVolume class ***"));

    wxArrayString volumes = wxFSVolume::GetVolumes();
    size_t count = volumes.GetCount();

    if ( !count )
    {
        wxPuts(wxT("ERROR: no mounted volumes?"));
        return;
    }

    wxPrintf(wxT("%u mounted volumes found:\n"), count);

    for ( size_t n = 0; n < count; n++ )
    {
        wxFSVolume vol(volumes[n]);
        if ( !vol.IsOk() )
        {
            wxPuts(wxT("ERROR: couldn't create volume"));
            continue;
        }

        wxPrintf(wxT("%u: %s (%s), %s, %s, %s\n"),
                 n + 1,
                 vol.GetDisplayName().c_str(),
                 vol.GetName().c_str(),
                 volumeKinds[vol.GetKind()],
                 vol.IsWritable() ? wxT("rw") : wxT("ro"),
                 vol.GetFlags() & wxFS_VOL_REMOVABLE ? wxT("removable")
                                                     : wxT("fixed"));
    }

    wxPuts("\n");
#endif // TEST_VOLUME
}
Commit	Line	Data
81ec0e15 FM	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/interactive/output.cpp
	3	// Purpose: Miscellaneous tests NOT requiring user input, just user checks
	4	// Author: Francesco Montorsi (extracted from console sample)
	5	// Created: 2010-06-21
81ec0e15 FM	6	// Copyright: (c) 2010 wxWidgets team
	7	///////////////////////////////////////////////////////////////////////////////
	8
	9	// ============================================================================
	10	// declarations
	11	// ============================================================================
	12
	13	// ----------------------------------------------------------------------------
	14	// headers
	15	// ----------------------------------------------------------------------------
	16
	17	#include "testprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
995202d0	23	#include "wx/app.h"
ddd4f327 FM	24	#include "wx/wxcrt.h" // for wxPuts
ddd4f327 FM	25	#include "wx/wxcrtvararg.h" // for wxPrintf
995202d0	26
81ec0e15 FM	27	// ----------------------------------------------------------------------------
	28	// conditional compilation
	29	// ----------------------------------------------------------------------------
	30
	31	#define TEST_DYNLIB
	32	#define TEST_MIME
	33	#define TEST_INFO_FUNCTIONS
	34	#define TEST_STACKWALKER
	35	#define TEST_STDPATHS
	36	#define TEST_VOLUME
	37
	38	// ----------------------------------------------------------------------------
	39	// test class
	40	// ----------------------------------------------------------------------------
	41
	42	class InteractiveOutputTestCase : public CppUnit::TestCase
	43	{
	44	public:
	45	InteractiveOutputTestCase() { }
	46
	47	private:
	48	CPPUNIT_TEST_SUITE( InteractiveOutputTestCase );
	49	CPPUNIT_TEST( TestDllListLoaded );
	50	CPPUNIT_TEST( TestMimeEnum );
	51	CPPUNIT_TEST( TestMimeAssociate );
	52	CPPUNIT_TEST( TestMimeFilename );
	53	CPPUNIT_TEST( TestOsInfo );
	54	CPPUNIT_TEST( TestPlatformInfo );
	55	CPPUNIT_TEST( TestUserInfo );
	56	CPPUNIT_TEST( TestStackWalk );
	57	CPPUNIT_TEST( TestStandardPaths );
	58	CPPUNIT_TEST( TestFSVolume );
	59	CPPUNIT_TEST_SUITE_END();
	60
	61	void TestDllListLoaded();
	62	void TestMimeEnum();
	63	void TestMimeAssociate();
	64	void TestMimeFilename();
	65	void TestOsInfo();
	66	void TestPlatformInfo();
	67	void TestUserInfo();
	68	void TestStackWalk();
	69	void TestStandardPaths();
	70	void TestFSVolume();
	71
	72	wxDECLARE_NO_COPY_CLASS(InteractiveOutputTestCase);
	73	};
	74
	75	// ----------------------------------------------------------------------------
	76	// CppUnit macros
	77	// ----------------------------------------------------------------------------
	78
	79	//CPPUNIT_TEST_SUITE_REGISTRATION( InteractiveOutputTestCase );
	80	// do not run this test by default!
	81
	82	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( InteractiveOutputTestCase, "InteractiveOutputTestCase" );
	83
	84	// ============================================================================
	85	// implementation
	86	// ============================================================================
	87
	88	// ----------------------------------------------------------------------------
	89	// wxDllLoader
	90	// ----------------------------------------------------------------------------
91
bb5a9514	92	#if !defined(__WINDOWS__) && !defined(__UNIX__)
81ec0e15 FM	93	#undef TEST_DYNLIB
	94	#endif
	95
	96	#include "wx/dynlib.h"
	97
	98	void InteractiveOutputTestCase::TestDllListLoaded()
	99	{
	100	#ifdef TEST_DYNLIB
	101	wxPuts(wxT("* testing wxDynamicLibrary::ListLoaded() *\n"));
	102
	103	wxPuts("Loaded modules:");
	104	wxDynamicLibraryDetailsArray dlls = wxDynamicLibrary::ListLoaded();
	105	const size_t count = dlls.GetCount();
	106	for ( size_t n = 0; n < count; ++n )
	107	{
	108	const wxDynamicLibraryDetails& details = dlls[n];
	109	printf("%-45s", (const char *)details.GetPath().mb_str());
	110
	111	void *addr wxDUMMY_INITIALIZE(NULL);
	112	size_t len wxDUMMY_INITIALIZE(0);
	113	if ( details.GetAddress(&addr, &len) )
	114	{
	115	printf(" %08lx:%08lx",
	116	(unsigned long)addr, (unsigned long)((char *)addr + len));
	117	}
	118
	119	printf(" %s\n", (const char *)details.GetVersion().mb_str());
	120	}
da569065	121
81ec0e15 FM	122	wxPuts(wxEmptyString);
	123	#endif // TEST_DYNLIB
	124	}
	125
	126
	127	// ----------------------------------------------------------------------------
	128	// MIME types
	129	// ----------------------------------------------------------------------------
	130
	131	#include "wx/mimetype.h"
	132
	133	void InteractiveOutputTestCase::TestMimeEnum()
	134	{
	135	#ifdef TEST_MIME
	136	wxPuts(wxT("* Testing wxMimeTypesManager::EnumAllFileTypes() *\n"));
	137
	138	wxArrayString mimetypes;
	139
	140	size_t count = wxTheMimeTypesManager->EnumAllFileTypes(mimetypes);
	141
	142	wxPrintf(wxT("* All %u known filetypes: *\n"), count);
	143
	144	wxArrayString exts;
	145	wxString desc;
	146
	147	for ( size_t n = 0; n < count; n++ )
	148	{
	149	wxFileType *filetype =
	150	wxTheMimeTypesManager->GetFileTypeFromMimeType(mimetypes[n]);
	151	if ( !filetype )
	152	{
	153	wxPrintf(wxT(" nothing known about the filetype '%s'!\n"),
	154	mimetypes[n].c_str());
	155	continue;
	156	}
	157
	158	filetype->GetDescription(&desc);
	159	filetype->GetExtensions(exts);
	160
	161	filetype->GetIcon(NULL);
	162
	163	wxString extsAll;
	164	for ( size_t e = 0; e < exts.GetCount(); e++ )
	165	{
	166	if ( e > 0 )
	167	extsAll << wxT(", ");
	168	extsAll += exts[e];
	169	}
	170
	171	wxPrintf(wxT(" %s: %s (%s)\n"),
	172	mimetypes[n].c_str(), desc.c_str(), extsAll.c_str());
	173	}
	174
	175	wxPuts(wxEmptyString);
	176	#endif // TEST_MIME
	177	}
	178
	179	void InteractiveOutputTestCase::TestMimeFilename()
	180	{
	181	#ifdef TEST_MIME
	182	wxPuts(wxT("* Testing MIME type from filename query *\n"));
	183
	184	static const wxChar *filenames[] =
	185	{
186	wxT("readme.txt"),
187	wxT("document.pdf"),
188	wxT("image.gif"),
189	wxT("picture.jpeg"),
190	};
191
192	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
193	{
194	const wxString fname = filenames[n];
195	wxString ext = fname.AfterLast(wxT('.'));
196	wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext);
197	if ( !ft )
198	{
199	wxPrintf(wxT("WARNING: extension '%s' is unknown.\n"), ext.c_str());
200	}
201	else
202	{
203	wxString desc;
204	if ( !ft->GetDescription(&desc) )
205	desc = wxT("<no description>");
206
207	wxString cmd;
208	if ( !ft->GetOpenCommand(&cmd,
209	wxFileType::MessageParameters(fname, wxEmptyString)) )
210	cmd = wxT("<no command available>");
211	else
212	cmd = wxString(wxT('"')) + cmd + wxT('"');
213
214	wxPrintf(wxT("To open %s (%s) run:\n %s\n"),
215	fname.c_str(), desc.c_str(), cmd.c_str());
216
217	delete ft;
218	}
219	}
220
221	wxPuts(wxEmptyString);
222	#endif // TEST_MIME
223	}
224
225	void InteractiveOutputTestCase::TestMimeAssociate()
226	{
227	#ifdef TEST_MIME
228	wxPuts(wxT("* Testing creation of filetype association *\n"));
229
df53be12 VZ	230	wxFileTypeInfo ftInfo("application/x-xyz");
	231	ftInfo.SetOpenCommand("xyzview '%s'");
	232	ftInfo.SetDescription("XYZ File");
	233	ftInfo.AddExtension(".xyz");
81ec0e15 FM	234	ftInfo.SetShortDesc(wxT("XYZFile")); // used under Win32 only
	235
	236	wxFileType *ft = wxTheMimeTypesManager->Associate(ftInfo);
	237	if ( !ft )
	238	{
	239	wxPuts(wxT("ERROR: failed to create association!"));
	240	}
	241	else
	242	{
	243	// TODO: read it back
	244	delete ft;
	245	}
	246
	247	wxPuts(wxEmptyString);
	248	#endif // TEST_MIME
	249	}
	250
	251
	252	// ----------------------------------------------------------------------------
	253	// misc information functions
	254	// ----------------------------------------------------------------------------
	255
	256	#include "wx/utils.h"
	257
	258	void InteractiveOutputTestCase::TestOsInfo()
	259	{
	260	#ifdef TEST_INFO_FUNCTIONS
	261	wxPuts(wxT("* Testing OS info functions *\n"));
	262
	263	int major, minor;
	264	wxGetOsVersion(&major, &minor);
	265	wxPrintf(wxT("Running under: %s, version %d.%d\n"),
	266	wxGetOsDescription().c_str(), major, minor);
	267
	268	wxPrintf(wxT("%ld free bytes of memory left.\n"), wxGetFreeMemory().ToLong());
	269
	270	wxPrintf(wxT("Host name is %s (%s).\n"),
	271	wxGetHostName().c_str(), wxGetFullHostName().c_str());
	272
	273	wxPuts(wxEmptyString);
	274	#endif // TEST_INFO_FUNCTIONS
	275	}
	276
	277	void InteractiveOutputTestCase::TestPlatformInfo()
	278	{
	279	#ifdef TEST_INFO_FUNCTIONS
	280	wxPuts(wxT("* Testing wxPlatformInfo functions *\n"));
	281
	282	// get this platform
	283	wxPlatformInfo plat;
	284
	285	wxPrintf(wxT("Operating system family name is: %s\n"), plat.GetOperatingSystemFamilyName().c_str());
	286	wxPrintf(wxT("Operating system name is: %s\n"), plat.GetOperatingSystemIdName().c_str());
	287	wxPrintf(wxT("Port ID name is: %s\n"), plat.GetPortIdName().c_str());
	288	wxPrintf(wxT("Port ID short name is: %s\n"), plat.GetPortIdShortName().c_str());
	289	wxPrintf(wxT("Architecture is: %s\n"), plat.GetArchName().c_str());
	290	wxPrintf(wxT("Endianness is: %s\n"), plat.GetEndiannessName().c_str());
	291
	292	wxPuts(wxEmptyString);
	293	#endif // TEST_INFO_FUNCTIONS
	294	}
	295
	296	void InteractiveOutputTestCase::TestUserInfo()
	297	{
298	#ifdef TEST_INFO_FUNCTIONS
299	wxPuts(wxT("* Testing user info functions *\n"));
300
301	wxPrintf(wxT("User id is:\t%s\n"), wxGetUserId().c_str());
302	wxPrintf(wxT("User name is:\t%s\n"), wxGetUserName().c_str());
303	wxPrintf(wxT("Home dir is:\t%s\n"), wxGetHomeDir().c_str());
304	wxPrintf(wxT("Email address:\t%s\n"), wxGetEmailAddress().c_str());
305
306	wxPuts(wxEmptyString);
307	#endif // TEST_INFO_FUNCTIONS
308	}
309
310
311	// ----------------------------------------------------------------------------
312	// stack backtrace
313	// ----------------------------------------------------------------------------
314
ddd4f327 FM	315	#if wxUSE_STACKWALKER
ddd4f327 FM	316
81ec0e15 FM	317	#include "wx/stackwalk.h"
	318
	319	class StackDump : public wxStackWalker
	320	{
	321	public:
	322	StackDump(const char *argv0)
	323	: wxStackWalker(argv0)
	324	{
	325	}
da569065	326
81ec0e15 FM	327	virtual void Walk(size_t skip = 1, size_t maxdepth = wxSTACKWALKER_MAX_DEPTH)
	328	{
	329	wxPuts(wxT("Stack dump:"));
	330
	331	wxStackWalker::Walk(skip, maxdepth);
	332	}
	333
	334	protected:
	335	virtual void OnStackFrame(const wxStackFrame& frame)
	336	{
	337	printf("[%2d] ", (int) frame.GetLevel());
	338
	339	wxString name = frame.GetName();
	340	if ( !name.empty() )
	341	{
	342	printf("%-20.40s", (const char*)name.mb_str());
	343	}
	344	else
	345	{
	346	printf("0x%08lx", (unsigned long)frame.GetAddress());
	347	}
	348
	349	if ( frame.HasSourceLocation() )
	350	{
	351	printf("\t%s:%d",
	352	(const char*)frame.GetFileName().mb_str(),
	353	(int)frame.GetLine());
	354	}
	355
	356	puts("");
	357
	358	wxString type, val;
	359	for ( size_t n = 0; frame.GetParam(n, &type, &name, &val); n++ )
	360	{
	361	printf("\t%s %s = %s\n", (const char*)type.mb_str(),
	362	(const char*)name.mb_str(),
	363	(const char*)val.mb_str());
	364	}
	365	}
	366	};
ddd4f327	367	#endif
81ec0e15 FM	368
	369	void InteractiveOutputTestCase::TestStackWalk()
	370	{
	371	#ifdef TEST_STACKWALKER
ddd4f327	372	#if wxUSE_STACKWALKER
81ec0e15 FM	373	wxPuts(wxT("* Testing wxStackWalker *"));
81ec0e15 FM	374
0fbd8b9b VZ	375	wxString progname(wxTheApp->argv[0]);
0fbd8b9b VZ	376	StackDump dump(progname.utf8_str());
81ec0e15	377	dump.Walk();
da569065	378
81ec0e15	379	wxPuts("\n");
ddd4f327	380	#endif
81ec0e15 FM	381	#endif // TEST_STACKWALKER
	382	}
	383
	384
	385	// ----------------------------------------------------------------------------
	386	// standard paths
	387	// ----------------------------------------------------------------------------
	388
81ec0e15 FM	389	#include "wx/stdpaths.h"
	390	#include "wx/wxchar.h" // wxPrintf
	391
	392	void InteractiveOutputTestCase::TestStandardPaths()
	393	{
	394	#ifdef TEST_STDPATHS
	395	wxPuts(wxT("* Testing wxStandardPaths *"));
	396
	397	wxTheApp->SetAppName(wxT("console"));
	398
	399	wxStandardPathsBase& stdp = wxStandardPaths::Get();
	400	wxPrintf(wxT("Config dir (sys):\t%s\n"), stdp.GetConfigDir().c_str());
	401	wxPrintf(wxT("Config dir (user):\t%s\n"), stdp.GetUserConfigDir().c_str());
	402	wxPrintf(wxT("Data dir (sys):\t\t%s\n"), stdp.GetDataDir().c_str());
	403	wxPrintf(wxT("Data dir (sys local):\t%s\n"), stdp.GetLocalDataDir().c_str());
	404	wxPrintf(wxT("Data dir (user):\t%s\n"), stdp.GetUserDataDir().c_str());
	405	wxPrintf(wxT("Data dir (user local):\t%s\n"), stdp.GetUserLocalDataDir().c_str());
	406	wxPrintf(wxT("Documents dir:\t\t%s\n"), stdp.GetDocumentsDir().c_str());
	407	wxPrintf(wxT("Executable path:\t%s\n"), stdp.GetExecutablePath().c_str());
	408	wxPrintf(wxT("Plugins dir:\t\t%s\n"), stdp.GetPluginsDir().c_str());
	409	wxPrintf(wxT("Resources dir:\t\t%s\n"), stdp.GetResourcesDir().c_str());
	410	wxPrintf(wxT("Localized res. dir:\t%s\n"),
	411	stdp.GetLocalizedResourcesDir(wxT("fr")).c_str());
	412	wxPrintf(wxT("Message catalogs dir:\t%s\n"),
	413	stdp.GetLocalizedResourcesDir
	414	(
	415	wxT("fr"),
	416	wxStandardPaths::ResourceCat_Messages
	417	).c_str());
da569065	418
81ec0e15 FM	419	wxPuts("\n");
	420	#endif // TEST_STDPATHS
	421	}
	422
	423
	424	// ----------------------------------------------------------------------------
	425	// wxVolume tests
	426	// ----------------------------------------------------------------------------
	427
	428	#if !defined(__WIN32__) \|\| !wxUSE_FSVOLUME
	429	#undef TEST_VOLUME
	430	#endif
	431
995202d0	432	#ifdef TEST_VOLUME
81ec0e15	433
995202d0	434	#include "wx/volume.h"
81ec0e15 FM	435	static const wxChar *volumeKinds[] =
	436	{
	437	wxT("floppy"),
	438	wxT("hard disk"),
	439	wxT("CD-ROM"),
	440	wxT("DVD-ROM"),
	441	wxT("network volume"),
	442	wxT("other volume"),
	443	};
	444
995202d0 FM	445	#endif
995202d0 FM	446
81ec0e15 FM	447	void InteractiveOutputTestCase::TestFSVolume()
	448	{
	449	#ifdef TEST_VOLUME
	450	wxPuts(wxT("* Testing wxFSVolume class *"));
	451
	452	wxArrayString volumes = wxFSVolume::GetVolumes();
	453	size_t count = volumes.GetCount();
	454
	455	if ( !count )
	456	{
	457	wxPuts(wxT("ERROR: no mounted volumes?"));
	458	return;
	459	}
	460
	461	wxPrintf(wxT("%u mounted volumes found:\n"), count);
	462
	463	for ( size_t n = 0; n < count; n++ )
	464	{
	465	wxFSVolume vol(volumes[n]);
	466	if ( !vol.IsOk() )
	467	{
	468	wxPuts(wxT("ERROR: couldn't create volume"));
	469	continue;
	470	}
	471
	472	wxPrintf(wxT("%u: %s (%s), %s, %s, %s\n"),
	473	n + 1,
	474	vol.GetDisplayName().c_str(),
	475	vol.GetName().c_str(),
	476	volumeKinds[vol.GetKind()],
	477	vol.IsWritable() ? wxT("rw") : wxT("ro"),
	478	vol.GetFlags() & wxFS_VOL_REMOVABLE ? wxT("removable")
	479	: wxT("fixed"));
	480	}
da569065	481
81ec0e15 FM	482	wxPuts("\n");
	483	#endif // TEST_VOLUME
	484	}
	485