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