// conditional compilation
// ----------------------------------------------------------------------------
+/*
+ A note about all these conditional compilation macros: this file is used
+ both as a test suite for various non-GUI wxWindows classes and as a
+ scratchpad for quick tests. So there are two compilation modes: if you
+ define TEST_ALL all tests are run, otherwise you may enable the individual
+ tests individually in the "#else" branch below.
+ */
+
// what to test (in alphabetic order)? uncomment the line below to do all tests
-//#define TEST_ALL
+// #define TEST_ALL
#ifdef TEST_ALL
#define TEST_ARRAYS
#define TEST_CHARSET
#define TEST_FILETIME
#define TEST_FTP
#define TEST_HASH
+ #define TEST_HASHMAP
#define TEST_INFO_FUNCTIONS
#define TEST_LIST
#define TEST_LOCALE
#define TEST_LONGLONG
#define TEST_MIME
#define TEST_PATHLIST
+ #define TEST_ODBC
#define TEST_REGCONF
#define TEST_REGEX
#define TEST_REGISTRY
#define TEST_THREADS
#define TEST_TIMER
// #define TEST_VCARD -- don't enable this (VZ)
+ #define TEST_VOLUME
#define TEST_WCHAR
#define TEST_ZIP
#define TEST_ZLIB
+
+ #undef TEST_ALL
+ static const bool TEST_ALL = TRUE;
#else
#define TEST_FILENAME
+
+ static const bool TEST_ALL = FALSE;
#endif
-#ifdef TEST_SNGLINST
- #include "wx/snglinst.h"
-#endif // TEST_SNGLINST
+// some tests are interactive, define this to run them
+#ifdef TEST_INTERACTIVE
+ #undef TEST_INTERACTIVE
+
+ static const bool TEST_INTERACTIVE = TRUE;
+#else
+ static const bool TEST_INTERACTIVE = FALSE;
+#endif
// ----------------------------------------------------------------------------
// test class for container objects
for ( size_t n = 0; n < WXSIZEOF(charsets); n++ )
{
- wxFontEncoding enc = wxTheFontMapper->CharsetToEncoding(charsets[n]);
+ wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charsets[n]);
wxPrintf(_T("Charset: %s\tEncoding: %s (%s)\n"),
charsets[n],
- wxTheFontMapper->GetEncodingName(enc).c_str(),
- wxTheFontMapper->GetEncodingDescription(enc).c_str());
+ wxFontMapper::Get()->GetEncodingName(enc).c_str(),
+ wxFontMapper::Get()->GetEncodingDescription(enc).c_str());
}
}
printf("\targc = %u\n", count);
for ( size_t arg = 0; arg < count; arg++ )
{
- printf("\targv[%u] = %s\n", arg, args[arg]);
+ printf("\targv[%u] = %s\n", arg, args[arg].c_str());
}
}
}
#include "wx/filename.h"
+static void DumpFileName(const wxFileName& fn)
+{
+ wxString full = fn.GetFullPath();
+
+ wxString vol, path, name, ext;
+ wxFileName::SplitPath(full, &vol, &path, &name, &ext);
+
+ wxPrintf(_T("'%s'-> vol '%s', path '%s', name '%s', ext '%s'\n"),
+ full.c_str(), vol.c_str(), path.c_str(), name.c_str(), ext.c_str());
+
+ wxFileName::SplitPath(full, &path, &name, &ext);
+ wxPrintf(_T("or\t\t-> path '%s', name '%s', ext '%s'\n"),
+ path.c_str(), name.c_str(), ext.c_str());
+
+ wxPrintf(_T("path is also:\t'%s'\n"), fn.GetPath().c_str());
+ wxPrintf(_T("with volume: \t'%s'\n"),
+ fn.GetPath(wxPATH_GET_VOLUME).c_str());
+ wxPrintf(_T("with separator:\t'%s'\n"),
+ fn.GetPath(wxPATH_GET_SEPARATOR).c_str());
+ wxPrintf(_T("with both: \t'%s'\n"),
+ fn.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).c_str());
+}
+
static struct FileNameInfo
{
const wxChar *fullname;
{ _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), TRUE, wxPATH_DOS },
{ _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), TRUE, wxPATH_DOS },
+ // wxFileName support for Mac file names is broken currently
+#if 0
// Mac file names
{ _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
+ { _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), TRUE, wxPATH_MAC },
+ { _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), TRUE, wxPATH_MAC },
{ _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), FALSE, wxPATH_MAC },
- { _T(":File"), _T(""), _T(""), _T("File"), _T(""), FALSE, wxPATH_MAC },
- { _T("File"), _T(""), _T(""), _T("File"), _T(""), FALSE, wxPATH_MAC },
+ { _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
+ { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), FALSE, wxPATH_MAC },
+#endif // 0
// VMS file names
{ _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE, wxPATH_VMS },
static const char *tmpprefixes[] =
{
+ "",
"foo",
- "/tmp/foo",
"..",
"../bar",
+#ifdef __UNIX__
+ "/tmp/foo",
"/tmp/foo/bar", // this one must be an error
+#endif // __UNIX__
};
for ( size_t n = 0; n < WXSIZEOF(tmpprefixes); n++ )
{
wxString path = wxFileName::CreateTempFileName(tmpprefixes[n]);
- if ( !path.empty() )
+ if ( path.empty() )
+ {
+ // "error" is not in upper case because it may be ok
+ printf("Prefix '%s'\t-> error\n", tmpprefixes[n]);
+ }
+ else
{
printf("Prefix '%s'\t-> temp file '%s'\n",
tmpprefixes[n], path.c_str());
}
}
+static void TestFileNameMakeRelative()
+{
+ puts("*** testing wxFileName::MakeRelativeTo() ***");
+
+ for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
+ {
+ const FileNameInfo& fni = filenames[n];
+
+ wxFileName fn(fni.fullname, fni.format);
+
+ // choose the base dir of the same format
+ wxString base;
+ switch ( fni.format )
+ {
+ case wxPATH_UNIX:
+ base = "/usr/bin/";
+ break;
+
+ case wxPATH_DOS:
+ base = "c:\\";
+ break;
+
+ case wxPATH_MAC:
+ case wxPATH_VMS:
+ // TODO: I don't know how this is supposed to work there
+ continue;
+
+ case wxPATH_NATIVE: // make gcc happy
+ default:
+ wxFAIL_MSG( "unexpected path format" );
+ }
+
+ printf("'%s' relative to '%s': ",
+ fn.GetFullPath(fni.format).c_str(), base.c_str());
+
+ if ( !fn.MakeRelativeTo(base, fni.format) )
+ {
+ puts("unchanged");
+ }
+ else
+ {
+ printf("'%s'\n", fn.GetFullPath(fni.format).c_str());
+ }
+ }
+}
+
static void TestFileNameComparison()
{
// TODO!
{
wxFileName fn(_T("testdata.fc"));
- wxDateTime dtAccess, dtMod, dtChange;
- if ( !fn.GetTimes(&dtAccess, &dtMod, &dtChange) )
+ wxDateTime dtAccess, dtMod, dtCreate;
+ if ( !fn.GetTimes(&dtAccess, &dtMod, &dtCreate) )
{
wxPrintf(_T("ERROR: GetTimes() failed.\n"));
}
static const wxChar *fmt = _T("%Y-%b-%d %H:%M:%S");
wxPrintf(_T("File times for '%s':\n"), fn.GetFullPath().c_str());
- wxPrintf(_T("Access: \t%s\n"), dtAccess.Format(fmt).c_str());
- wxPrintf(_T("Mod/creation:\t%s\n"), dtMod.Format(fmt).c_str());
- wxPrintf(_T("Change: \t%s\n"), dtChange.Format(fmt).c_str());
+ wxPrintf(_T("Creation: \t%s\n"), dtCreate.Format(fmt).c_str());
+ wxPrintf(_T("Last read: \t%s\n"), dtAccess.Format(fmt).c_str());
+ wxPrintf(_T("Last write: \t%s\n"), dtMod.Format(fmt).c_str());
}
}
{
wxFileName fn(_T("testdata.fc"));
- wxDateTime dtAccess, dtMod, dtChange;
if ( !fn.Touch() )
{
wxPrintf(_T("ERROR: Touch() failed.\n"));
#endif // TEST_HASH
+// ----------------------------------------------------------------------------
+// wxHashMap
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_HASHMAP
+
+#include "wx/hashmap.h"
+
+// test compilation of basic map types
+WX_DECLARE_HASH_MAP( int*, int*, wxPointerHash, wxPointerEqual, myPtrHashMap );
+WX_DECLARE_HASH_MAP( long, long, wxIntegerHash, wxIntegerEqual, myLongHashMap );
+WX_DECLARE_HASH_MAP( unsigned long, unsigned, wxIntegerHash, wxIntegerEqual,
+ myUnsignedHashMap );
+WX_DECLARE_HASH_MAP( unsigned int, unsigned, wxIntegerHash, wxIntegerEqual,
+ myTestHashMap1 );
+WX_DECLARE_HASH_MAP( int, unsigned, wxIntegerHash, wxIntegerEqual,
+ myTestHashMap2 );
+WX_DECLARE_HASH_MAP( short, unsigned, wxIntegerHash, wxIntegerEqual,
+ myTestHashMap3 );
+WX_DECLARE_HASH_MAP( unsigned short, unsigned, wxIntegerHash, wxIntegerEqual,
+ myTestHashMap4 );
+
+// same as:
+// WX_DECLARE_HASH_MAP( wxString, wxString, wxStringHash, wxStringEqual,
+// myStringHashMap );
+WX_DECLARE_STRING_HASH_MAP(wxString, myStringHashMap);
+
+typedef myStringHashMap::iterator Itor;
+
+static void TestHashMap()
+{
+ puts("*** Testing wxHashMap ***\n");
+ myStringHashMap sh(0); // as small as possible
+ wxString buf;
+ size_t i;
+ const size_t count = 10000;
+
+ // init with some data
+ for( i = 0; i < count; ++i )
+ {
+ buf.Printf(wxT("%d"), i );
+ sh[buf] = wxT("A") + buf + wxT("C");
+ }
+
+ // test that insertion worked
+ if( sh.size() != count )
+ {
+ printf("*** ERROR: %u ELEMENTS, SHOULD BE %u ***\n", sh.size(), count);
+ }
+
+ for( i = 0; i < count; ++i )
+ {
+ buf.Printf(wxT("%d"), i );
+ if( sh[buf] != wxT("A") + buf + wxT("C") )
+ {
+ printf("*** ERROR INSERTION BROKEN! STOPPING NOW! ***\n");
+ return;
+ }
+ }
+
+ // check that iterators work
+ Itor it;
+ for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
+ {
+ if( i == count )
+ {
+ printf("*** ERROR ITERATORS DO NOT TERMINATE! STOPPING NOW! ***\n");
+ return;
+ }
+
+ if( it->second != sh[it->first] )
+ {
+ printf("*** ERROR ITERATORS BROKEN! STOPPING NOW! ***\n");
+ return;
+ }
+ }
+
+ if( sh.size() != i )
+ {
+ printf("*** ERROR: %u ELEMENTS ITERATED, SHOULD BE %u ***\n", i, count);
+ }
+
+ // test copy ctor, assignment operator
+ myStringHashMap h1( sh ), h2( 0 );
+ h2 = sh;
+
+ for( i = 0, it = sh.begin(); it != sh.end(); ++it, ++i )
+ {
+ if( h1[it->first] != it->second )
+ {
+ printf("*** ERROR: COPY CTOR BROKEN %s ***\n", it->first.c_str());
+ }
+
+ if( h2[it->first] != it->second )
+ {
+ printf("*** ERROR: OPERATOR= BROKEN %s ***\n", it->first.c_str());
+ }
+ }
+
+ // other tests
+ for( i = 0; i < count; ++i )
+ {
+ buf.Printf(wxT("%d"), i );
+ size_t sz = sh.size();
+
+ // test find() and erase(it)
+ if( i < 100 )
+ {
+ it = sh.find( buf );
+ if( it != sh.end() )
+ {
+ sh.erase( it );
+
+ if( sh.find( buf ) != sh.end() )
+ {
+ printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i);
+ }
+ }
+ else
+ printf("*** ERROR: CANT FIND ELEMENT %u ***\n", i);
+ }
+ else
+ // test erase(key)
+ {
+ size_t c = sh.erase( buf );
+ if( c != 1 )
+ printf("*** ERROR: SHOULD RETURN 1 ***\n");
+
+ if( sh.find( buf ) != sh.end() )
+ {
+ printf("*** ERROR: FOUND DELETED ELEMENT %u ***\n", i);
+ }
+ }
+
+ // count should decrease
+ if( sh.size() != sz - 1 )
+ {
+ printf("*** ERROR: COUNT DID NOT DECREASE ***\n");
+ }
+ }
+
+ printf("*** Finished testing wxHashMap ***\n");
+}
+
+#endif // TEST_HASHMAP
+
// ----------------------------------------------------------------------------
// wxList
// ----------------------------------------------------------------------------
{
static const char *languageNames[] =
{
- "DEFAULT",
- "UNKNOWN",
+ "DEFAULT",
+ "UNKNOWN",
"ABKHAZIAN",
"AFAR",
"AFRIKAANS",
_T("application/x-xyz"),
_T("xyzview '%s'"), // open cmd
_T(""), // print cmd
- _T("XYZ File") // description
- _T(".xyz"), // extensions
- NULL // end of extensions
+ _T("XYZ File"), // description
+ _T(".xyz"), // extensions
+ NULL // end of extensions
);
ftInfo.SetShortDesc(_T("XYZFile")); // used under Win32 only
// multiplication will not overflow)
wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
- // get a random long (not wxLongLong for now) to divide it with
- long l = rand();
+ // get a random (but non null) long (not wxLongLong for now) to divide
+ // it with
+ long l;
+ do
+ {
+ l = rand();
+ }
+ while ( !l );
+
q = ll / l;
r = ll % l;
};
const wxChar *pattern = _T("([a-z]+)[^0-9]*([0-9]+)");
- wxRegEx re = pattern;
+ wxRegEx re(pattern);
wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern);
#endif // TEST_REGEX
+// ----------------------------------------------------------------------------
+// database
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_ODBC
+
+#include <wx/db.h>
+
+static void TestDbOpen()
+{
+ HENV henv;
+ wxDb db(henv);
+}
+
+#endif // TEST_ODBC
+
// ----------------------------------------------------------------------------
// registry and related stuff
// ----------------------------------------------------------------------------
puts("*** Testing wxStopWatch ***\n");
wxStopWatch sw;
- printf("Sleeping 3 seconds...");
+ sw.Pause();
+ printf("Initially paused, after 2 seconds time is...");
+ fflush(stdout);
+ wxSleep(2);
+ printf("\t%ldms\n", sw.Time());
+
+ printf("Resuming stopwatch and sleeping 3 seconds...");
+ fflush(stdout);
+ sw.Resume();
wxSleep(3);
printf("\telapsed time: %ldms\n", sw.Time());
sw.Pause();
- printf("Sleeping 2 more seconds...");
+ printf("Pausing agan and sleeping 2 more seconds...");
+ fflush(stdout);
wxSleep(2);
printf("\telapsed time: %ldms\n", sw.Time());
sw.Resume();
- printf("And 3 more seconds...");
- wxSleep(3);
+ printf("Finally resuming and sleeping 2 more seconds...");
+ fflush(stdout);
+ wxSleep(2);
printf("\telapsed time: %ldms\n", sw.Time());
wxStopWatch sw2;
}
putchar('.');
+ fflush(stdout);
}
puts(", ok.");
#endif // TEST_VCARD
+// ----------------------------------------------------------------------------
+// wxVolume tests
+// ----------------------------------------------------------------------------
+
+#if !wxUSE_FSVOLUME
+ #undef TEST_VOLUME
+#endif
+
+#ifdef TEST_VOLUME
+
+#include "wx/volume.h"
+
+static const wxChar *volumeKinds[] =
+{
+ _T("floppy"),
+ _T("hard disk"),
+ _T("CD-ROM"),
+ _T("DVD-ROM"),
+ _T("network volume"),
+ _T("other volume"),
+};
+
+static void TestFSVolume()
+{
+ wxPuts(_T("*** Testing wxFSVolume class ***"));
+
+ wxArrayString volumes = wxFSVolume::GetVolumes();
+ size_t count = volumes.GetCount();
+
+ if ( !count )
+ {
+ wxPuts(_T("ERROR: no mounted volumes?"));
+ return;
+ }
+
+ wxPrintf(_T("%u mounted volumes found:\n"), count);
+
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxFSVolume vol(volumes[n]);
+ if ( !vol.IsOk() )
+ {
+ wxPuts(_T("ERROR: couldn't create volume"));
+ continue;
+ }
+
+ wxPrintf(_T("%u: %s (%s), %s, %s, %s\n"),
+ n + 1,
+ vol.GetDisplayName().c_str(),
+ vol.GetName().c_str(),
+ volumeKinds[vol.GetKind()],
+ vol.IsWritable() ? _T("rw") : _T("ro"),
+ vol.GetFlags() & wxFS_VOL_REMOVABLE ? _T("removable")
+ : _T("fixed"));
+ }
+}
+
+#endif // TEST_VOLUME
+
// ----------------------------------------------------------------------------
// wide char (Unicode) support
// ----------------------------------------------------------------------------
#include "wx/encconv.h"
#include "wx/buffer.h"
+static const char textInUtf8[] =
+{
+ 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
+ 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
+ 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
+ 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
+ 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
+ 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
+ 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
+};
+
static void TestUtf8()
{
puts("*** Testing UTF8 support ***\n");
- static const char textInUtf8[] =
- {
- 208, 157, 208, 181, 209, 129, 208, 186, 208, 176, 208, 183, 208, 176,
- 208, 189, 208, 189, 208, 190, 32, 208, 191, 208, 190, 209, 128, 208,
- 176, 208, 180, 208, 190, 208, 178, 208, 176, 208, 187, 32, 208, 188,
- 208, 181, 208, 189, 209, 143, 32, 209, 129, 208, 178, 208, 190, 208,
- 181, 208, 185, 32, 208, 186, 209, 128, 209, 131, 209, 130, 208, 181,
- 208, 185, 209, 136, 208, 181, 208, 185, 32, 208, 189, 208, 190, 208,
- 178, 208, 190, 209, 129, 209, 130, 209, 140, 209, 142, 0
- };
-
char buf[1024];
wchar_t wbuf[1024];
if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
}
else
{
- // using wxEncodingConverter
-#if 0
- wxEncodingConverter ec;
- ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
- ec.Convert(wbuf, buf);
-#else // using wxCSConv
wxCSConv conv(_T("koi8-r"));
if ( conv.WC2MB(buf, wbuf, 0 /* not needed wcslen(wbuf) */) <= 0 )
{
puts("ERROR: conversion to KOI8-R failed.");
}
else
-#endif
+ {
+ printf("The resulting string (in KOI8-R): %s\n", buf);
+ }
+ }
- printf("The resulting string (in koi8-r): %s\n", buf);
+ if ( wxConvUTF8.WC2MB(buf, L"Ã la", WXSIZEOF(buf)) <= 0 )
+ {
+ puts("ERROR: conversion to UTF-8 failed.");
+ }
+ else
+ {
+ printf("The string in UTF-8: %s\n", buf);
}
+
+ puts("");
+}
+
+static void TestEncodingConverter()
+{
+ wxPuts(_T("*** Testing wxEncodingConverter ***\n"));
+
+ // using wxEncodingConverter should give the same result as above
+ char buf[1024];
+ wchar_t wbuf[1024];
+ if ( wxConvUTF8.MB2WC(wbuf, textInUtf8, WXSIZEOF(textInUtf8)) <= 0 )
+ {
+ puts("ERROR: UTF-8 decoding failed.");
+ }
+ else
+ {
+ wxEncodingConverter ec;
+ ec.Init(wxFONTENCODING_UNICODE, wxFONTENCODING_KOI8);
+ ec.Convert(wbuf, buf);
+ printf("The same string obtained using wxEC: %s\n", buf);
+ }
+
+ puts("");
}
#endif // TEST_WCHAR
static size_t gs_counter = (size_t)-1;
static wxCriticalSection gs_critsect;
-static wxCondition gs_cond;
+static wxSemaphore gs_cond;
class MyJoinableThread : public wxThread
{
wxCriticalSectionLocker lock(gs_critsect);
if ( !--gs_counter && !m_cancelled )
- gs_cond.Signal();
+ gs_cond.Post();
}
-void TestDetachedThreads()
+static void TestDetachedThreads()
{
puts("\n*** Testing detached threads ***");
puts("");
}
-void TestJoinableThreads()
+static void TestJoinableThreads()
{
puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
(unsigned long)thread.Wait());
}
-void TestThreadSuspend()
+static void TestThreadSuspend()
{
puts("\n*** Testing thread suspend/resume functions ***");
puts("");
}
-void TestThreadDelete()
+static void TestThreadDelete()
{
// As above, using Sleep() is only for testing here - we must use some
// synchronisation object instead to ensure that the thread is still
puts("");
}
-#endif // TEST_THREADS
+class MyWaitingThread : public wxThread
+{
+public:
+ MyWaitingThread( wxMutex *mutex, wxCondition *condition )
+ {
+ m_mutex = mutex;
+ m_condition = condition;
-// ----------------------------------------------------------------------------
-// arrays
-// ----------------------------------------------------------------------------
+ Create();
+ }
-#ifdef TEST_ARRAYS
+ virtual ExitCode Entry()
+ {
+ printf("Thread %lu has started running.\n", GetId());
+ fflush(stdout);
-static void PrintArray(const char* name, const wxArrayString& array)
+ gs_cond.Post();
+
+ printf("Thread %lu starts to wait...\n", GetId());
+ fflush(stdout);
+
+ m_mutex->Lock();
+ m_condition->Wait();
+ m_mutex->Unlock();
+
+ printf("Thread %lu finished to wait, exiting.\n", GetId());
+ fflush(stdout);
+
+ return 0;
+ }
+
+private:
+ wxMutex *m_mutex;
+ wxCondition *m_condition;
+};
+
+static void TestThreadConditions()
{
- printf("Dump of the array '%s'\n", name);
+ wxMutex mutex;
+ wxCondition condition(mutex);
- size_t nCount = array.GetCount();
- for ( size_t n = 0; n < nCount; n++ )
+ // otherwise its difficult to understand which log messages pertain to
+ // which condition
+ //wxLogTrace("thread", "Local condition var is %08x, gs_cond = %08x",
+ // condition.GetId(), gs_cond.GetId());
+
+ // create and launch threads
+ MyWaitingThread *threads[10];
+
+ size_t n;
+ for ( n = 0; n < WXSIZEOF(threads); n++ )
{
- printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
+ threads[n] = new MyWaitingThread( &mutex, &condition );
}
-}
-static void PrintArray(const char* name, const wxArrayInt& array)
-{
- printf("Dump of the array '%s'\n", name);
+ for ( n = 0; n < WXSIZEOF(threads); n++ )
+ {
+ threads[n]->Run();
+ }
- size_t nCount = array.GetCount();
- for ( size_t n = 0; n < nCount; n++ )
+ // wait until all threads run
+ puts("Main thread is waiting for the other threads to start");
+ fflush(stdout);
+
+ size_t nRunning = 0;
+ while ( nRunning < WXSIZEOF(threads) )
{
- printf("\t%s[%u] = %d\n", name, n, array[n]);
+ gs_cond.Wait();
+
+ nRunning++;
+
+ printf("Main thread: %u already running\n", nRunning);
+ fflush(stdout);
}
+
+ puts("Main thread: all threads started up.");
+ fflush(stdout);
+
+ wxThread::Sleep(500);
+
+#if 1
+ // now wake one of them up
+ printf("Main thread: about to signal the condition.\n");
+ fflush(stdout);
+ condition.Signal();
+#endif
+
+ wxThread::Sleep(200);
+
+ // wake all the (remaining) threads up, so that they can exit
+ printf("Main thread: about to broadcast the condition.\n");
+ fflush(stdout);
+ condition.Broadcast();
+
+ // give them time to terminate (dirty!)
+ wxThread::Sleep(500);
}
-int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
- const wxString& second)
+#include "wx/utils.h"
+
+class MyExecThread : public wxThread
{
- return first.length() - second.length();
-}
+public:
+ MyExecThread(const wxString& command) : wxThread(wxTHREAD_JOINABLE),
+ m_command(command)
+ {
+ Create();
+ }
+
+ virtual ExitCode Entry()
+ {
+ return (ExitCode)wxExecute(m_command, wxEXEC_SYNC);
+ }
+
+private:
+ wxString m_command;
+};
-int wxCMPFUNC_CONV IntCompare(int *first,
- int *second)
+static void TestThreadExec()
{
- return *first - *second;
+ wxPuts(_T("*** Testing wxExecute interaction with threads ***\n"));
+
+ MyExecThread thread(_T("true"));
+ thread.Run();
+
+ wxPrintf(_T("Main program exit code: %ld.\n"),
+ wxExecute(_T("false"), wxEXEC_SYNC));
+
+ wxPrintf(_T("Thread exit code: %ld.\n"), (long)thread.Wait());
}
-int wxCMPFUNC_CONV IntRevCompare(int *first,
- int *second)
+// semaphore tests
+#include "wx/datetime.h"
+
+class MySemaphoreThread : public wxThread
{
- return *second - *first;
-}
+public:
+ MySemaphoreThread(int i, wxSemaphore *sem)
+ : wxThread(wxTHREAD_JOINABLE),
+ m_sem(sem),
+ m_i(i)
+ {
+ Create();
+ }
+
+ virtual ExitCode Entry()
+ {
+ wxPrintf(_T("%s: Thread %d starting to wait for semaphore...\n"),
+ wxDateTime::Now().FormatTime().c_str(), m_i);
+
+ m_sem->Wait();
+
+ wxPrintf(_T("%s: Thread %d acquired the semaphore.\n"),
+ wxDateTime::Now().FormatTime().c_str(), m_i);
+
+ Sleep(1000);
+
+ wxPrintf(_T("%s: Thread %d releasing the semaphore.\n"),
+ wxDateTime::Now().FormatTime().c_str(), m_i);
-static void TestArrayOfInts()
+ m_sem->Post();
+
+ return 0;
+ }
+
+private:
+ wxSemaphore *m_sem;
+ int m_i;
+};
+
+WX_DEFINE_ARRAY(wxThread *, ArrayThreads);
+
+static void TestSemaphore()
{
- puts("*** Testing wxArrayInt ***\n");
+ wxPuts(_T("*** Testing wxSemaphore class. ***"));
- wxArrayInt a;
- a.Add(1);
- a.Add(17);
- a.Add(5);
- a.Add(3);
+ static const int SEM_LIMIT = 3;
- puts("Initially:");
- PrintArray("a", a);
+ wxSemaphore sem(SEM_LIMIT, SEM_LIMIT);
+ ArrayThreads threads;
- puts("After sort:");
- a.Sort(IntCompare);
- PrintArray("a", a);
+ for ( int i = 0; i < 3*SEM_LIMIT; i++ )
+ {
+ threads.Add(new MySemaphoreThread(i, &sem));
+ threads.Last()->Run();
+ }
- puts("After reverse sort:");
- a.Sort(IntRevCompare);
- PrintArray("a", a);
+ for ( size_t n = 0; n < threads.GetCount(); n++ )
+ {
+ threads[n]->Wait();
+ delete threads[n];
+ }
}
+#endif // TEST_THREADS
+
+// ----------------------------------------------------------------------------
+// arrays
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_ARRAYS
+
#include "wx/dynarray.h"
+#define DefineCompare(name, T) \
+ \
+int wxCMPFUNC_CONV name ## CompareValues(T first, T second) \
+{ \
+ return first - second; \
+} \
+ \
+int wxCMPFUNC_CONV name ## Compare(T* first, T* second) \
+{ \
+ return *first - *second; \
+} \
+ \
+int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second) \
+{ \
+ return *second - *first; \
+} \
+
+DefineCompare(Short, short);
+DefineCompare(Int, int);
+
+// test compilation of all macros
+WX_DEFINE_ARRAY(short, wxArrayShort);
+WX_DEFINE_SORTED_ARRAY(short, wxSortedArrayShortNoCmp);
+WX_DEFINE_SORTED_ARRAY_CMP(short, ShortCompareValues, wxSortedArrayShort);
+WX_DEFINE_SORTED_ARRAY_CMP(int, IntCompareValues, wxSortedArrayInt);
+
WX_DECLARE_OBJARRAY(Bar, ArrayBars);
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(ArrayBars);
+static void PrintArray(const char* name, const wxArrayString& array)
+{
+ printf("Dump of the array '%s'\n", name);
+
+ size_t nCount = array.GetCount();
+ for ( size_t n = 0; n < nCount; n++ )
+ {
+ printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
+ }
+}
+
+int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
+ const wxString& second)
+{
+ return first.length() - second.length();
+}
+
+#define TestArrayOf(name) \
+ \
+static void PrintArray(const char* name, const wxSortedArray##name & array) \
+{ \
+ printf("Dump of the array '%s'\n", name); \
+ \
+ size_t nCount = array.GetCount(); \
+ for ( size_t n = 0; n < nCount; n++ ) \
+ { \
+ printf("\t%s[%u] = %d\n", name, n, array[n]); \
+ } \
+} \
+ \
+static void PrintArray(const char* name, const wxArray##name & array) \
+{ \
+ printf("Dump of the array '%s'\n", name); \
+ \
+ size_t nCount = array.GetCount(); \
+ for ( size_t n = 0; n < nCount; n++ ) \
+ { \
+ printf("\t%s[%u] = %d\n", name, n, array[n]); \
+ } \
+} \
+ \
+static void TestArrayOf ## name ## s() \
+{ \
+ printf("*** Testing wxArray%s ***\n", #name); \
+ \
+ wxArray##name a; \
+ a.Add(1); \
+ a.Add(17); \
+ a.Add(5); \
+ a.Add(3); \
+ \
+ puts("Initially:"); \
+ PrintArray("a", a); \
+ \
+ puts("After sort:"); \
+ a.Sort(name ## Compare); \
+ PrintArray("a", a); \
+ \
+ puts("After reverse sort:"); \
+ a.Sort(name ## RevCompare); \
+ PrintArray("a", a); \
+ \
+ wxSortedArray##name b; \
+ b.Add(1); \
+ b.Add(17); \
+ b.Add(5); \
+ b.Add(3); \
+ \
+ puts("Sorted array initially:"); \
+ PrintArray("b", b); \
+}
+
+TestArrayOf(Short);
+TestArrayOf(Int);
+
static void TestArrayOfObjects()
{
puts("*** Testing wxObjArray ***\n");
// entry point
// ----------------------------------------------------------------------------
+#ifdef TEST_SNGLINST
+ #include "wx/snglinst.h"
+#endif // TEST_SNGLINST
+
int main(int argc, char **argv)
{
wxInitializer initializer;
#endif // TEST_CMDLINE
#ifdef TEST_STRINGS
- if ( 0 )
+ if ( TEST_ALL )
{
TestPChar();
TestString();
TestStringTokenizer();
TestStringReplace();
}
- TestStringMatch();
+ else
+ {
+ TestStringMatch();
+ }
#endif // TEST_STRINGS
#ifdef TEST_ARRAYS
- if ( 0 )
+ if ( TEST_ALL )
{
- wxArrayString a1;
- a1.Add("tiger");
- a1.Add("cat");
- a1.Add("lion");
- a1.Add("dog");
- a1.Add("human");
- a1.Add("ape");
+ wxArrayString a1;
+ a1.Add("tiger");
+ a1.Add("cat");
+ a1.Add("lion");
+ a1.Add("dog");
+ a1.Add("human");
+ a1.Add("ape");
- puts("*** Initially:");
+ puts("*** Initially:");
- PrintArray("a1", a1);
+ PrintArray("a1", a1);
- wxArrayString a2(a1);
- PrintArray("a2", a2);
+ wxArrayString a2(a1);
+ PrintArray("a2", a2);
- wxSortedArrayString a3(a1);
- PrintArray("a3", a3);
+ wxSortedArrayString a3(a1);
+ PrintArray("a3", a3);
- puts("*** After deleting a string from a1");
- a1.Remove(2);
+ puts("*** After deleting a string from a1");
+ a1.Remove(2);
- PrintArray("a1", a1);
- PrintArray("a2", a2);
- PrintArray("a3", a3);
+ PrintArray("a1", a1);
+ PrintArray("a2", a2);
+ PrintArray("a3", a3);
- puts("*** After reassigning a1 to a2 and a3");
- a3 = a2 = a1;
- PrintArray("a2", a2);
- PrintArray("a3", a3);
+ puts("*** After reassigning a1 to a2 and a3");
+ a3 = a2 = a1;
+ PrintArray("a2", a2);
+ PrintArray("a3", a3);
- puts("*** After sorting a1");
- a1.Sort();
- PrintArray("a1", a1);
+ puts("*** After sorting a1");
+ a1.Sort();
+ PrintArray("a1", a1);
- puts("*** After sorting a1 in reverse order");
- a1.Sort(TRUE);
- PrintArray("a1", a1);
+ puts("*** After sorting a1 in reverse order");
+ a1.Sort(TRUE);
+ PrintArray("a1", a1);
- puts("*** After sorting a1 by the string length");
- a1.Sort(StringLenCompare);
- PrintArray("a1", a1);
+ puts("*** After sorting a1 by the string length");
+ a1.Sort(StringLenCompare);
+ PrintArray("a1", a1);
- TestArrayOfObjects();
+ TestArrayOfObjects();
+ TestArrayOfShorts();
}
+
TestArrayOfInts();
#endif // TEST_ARRAYS
#ifdef TEST_DIR
- if ( 0 )
+ if ( TEST_ALL )
+ {
TestDirEnum();
- TestDirTraverse();
+ TestDirTraverse();
+ }
#endif // TEST_DIR
#ifdef TEST_DLLLOADER
#endif // TEST_LOG
#ifdef TEST_FILE
- if ( 0 )
+ if ( TEST_ALL )
{
TestFileRead();
TestTextFileRead();
+ TestFileCopy();
}
- TestFileCopy();
#endif // TEST_FILE
#ifdef TEST_FILENAME
- TestFileNameTemp();
if ( 0 )
{
- TestFileNameConstruction();
- TestFileNameSplit();
+ wxFileName fn;
+ fn.Assign("c:\\foo", "bar.baz");
+
+ DumpFileName(fn);
+ }
+
+ if ( TEST_ALL )
+ {
+ TestFileNameConstruction();
+ TestFileNameMakeRelative();
+ TestFileNameSplit();
+ TestFileNameTemp();
TestFileNameCwd();
TestFileNameComparison();
TestFileNameOperations();
wxLog::AddTraceMask(FTP_TRACE_MASK);
if ( TestFtpConnect() )
{
- TestFtpFileSize();
- if ( 0 )
+ if ( TEST_ALL )
{
TestFtpList();
TestFtpDownload();
TestFtpMisc();
+ TestFtpFileSize();
TestFtpUpload();
}
- if ( 0 )
- TestFtpInteractive();
+
+ if ( TEST_INTERACTIVE )
+ TestFtpInteractive();
}
//else: connecting to the FTP server failed
TestFtpWuFtpd();
#endif // TEST_FTP
-#ifdef TEST_THREADS
- int nCPUs = wxThread::GetCPUCount();
- printf("This system has %d CPUs\n", nCPUs);
- if ( nCPUs != -1 )
- wxThread::SetConcurrency(nCPUs);
-
- if ( argc > 1 && argv[1][0] == 't' )
- wxLog::AddTraceMask("thread");
-
- if ( 1 )
- TestDetachedThreads();
- if ( 1 )
- TestJoinableThreads();
- if ( 1 )
- TestThreadSuspend();
- if ( 1 )
- TestThreadDelete();
-
-#endif // TEST_THREADS
-
#ifdef TEST_LONGLONG
// seed pseudo random generator
srand((unsigned)time(NULL));
{
TestSpeed();
}
- if ( 0 )
+
+ if ( TEST_ALL )
{
TestMultiplication();
TestDivision();
TestLongLongConversion();
TestBitOperations();
TestLongLongComparison();
+ TestLongLongPrint();
}
- TestLongLongPrint();
#endif // TEST_LONGLONG
#ifdef TEST_HASH
TestHash();
#endif // TEST_HASH
+#ifdef TEST_HASHMAP
+ TestHashMap();
+#endif // TEST_HASHMAP
+
#ifdef TEST_MIME
wxLog::AddTraceMask(_T("mime"));
- if ( 1 )
+ if ( TEST_ALL )
{
TestMimeEnum();
TestMimeOverride();
TestMimeFilename();
}
- else
- TestMimeAssociate();
+
+ TestMimeAssociate();
#endif // TEST_MIME
#ifdef TEST_INFO_FUNCTIONS
- TestDiskInfo();
- if ( 0 )
+ if ( TEST_ALL )
{
TestOsInfo();
TestUserInfo();
+
+ if ( TEST_INTERACTIVE )
+ TestDiskInfo();
}
#endif // TEST_INFO_FUNCTIONS
TestPathList();
#endif // TEST_PATHLIST
+#ifdef TEST_ODBC
+ TestDbOpen();
+#endif // TEST_ODBC
+
#ifdef TEST_REGCONF
TestRegConfWrite();
#endif // TEST_REGCONF
#ifdef TEST_REGEX
// TODO: write a real test using src/regex/tests file
- if ( 0 )
+ if ( TEST_ALL )
{
TestRegExCompile();
TestRegExMatch();
TestRegExSubmatch();
- TestRegExInteractive();
+ TestRegExReplacement();
+
+ if ( TEST_INTERACTIVE )
+ TestRegExInteractive();
}
- TestRegExReplacement();
#endif // TEST_REGEX
#ifdef TEST_REGISTRY
- if ( 0 )
- TestRegistryRead();
+ TestRegistryRead();
TestRegistryAssociation();
#endif // TEST_REGISTRY
#ifdef TEST_SOCKETS
- if ( 0 )
- {
- TestSocketServer();
- }
- TestSocketClient();
+ TestSocketServer();
+ TestSocketClient();
#endif // TEST_SOCKETS
#ifdef TEST_STREAMS
- if ( 0 )
TestFileStream();
TestMemoryStream();
#endif // TEST_STREAMS
+#ifdef TEST_THREADS
+ int nCPUs = wxThread::GetCPUCount();
+ printf("This system has %d CPUs\n", nCPUs);
+ if ( nCPUs != -1 )
+ wxThread::SetConcurrency(nCPUs);
+
+ if ( TEST_ALL )
+ {
+ TestDetachedThreads();
+ TestJoinableThreads();
+ TestThreadSuspend();
+ TestThreadDelete();
+ TestThreadConditions();
+ TestThreadExec();
+ }
+
+ TestSemaphore();
+#endif // TEST_THREADS
+
#ifdef TEST_TIMER
TestStopWatch();
#endif // TEST_TIMER
#ifdef TEST_DATETIME
- if ( 0 )
+ if ( TEST_ALL )
{
TestTimeSet();
TestTimeStatic();
TestTimeArithmetics();
TestTimeHolidays();
TestTimeFormat();
+ TestTimeSpanFormat();
TestTimeMS();
TestTimeZoneBug();
}
- TestTimeSpanFormat();
- if ( 0 )
+
+ if ( TEST_INTERACTIVE )
TestDateTimeInteractive();
#endif // TEST_DATETIME
#endif // TEST_USLEEP
#ifdef TEST_VCARD
- if ( 0 )
TestVCardRead();
TestVCardWrite();
#endif // TEST_VCARD
+#ifdef TEST_VOLUME
+ TestFSVolume();
+#endif // TEST_VOLUME
+
#ifdef TEST_WCHAR
TestUtf8();
+ TestEncodingConverter();
#endif // TEST_WCHAR
#ifdef TEST_ZIP
- if ( 0 )
- TestZipStreamRead();
+ TestZipStreamRead();
TestZipFileSystem();
#endif // TEST_ZIP
#ifdef TEST_ZLIB
- if ( 0 )
TestZlibStreamWrite();
TestZlibStreamRead();
#endif // TEST_ZLIB
projects / wxWidgets.git / blobdiff