// 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_WCHAR
#define TEST_ZIP
#define TEST_ZLIB
+
+ #undef TEST_ALL
+ static const bool TEST_ALL = TRUE;
#else
- #define TEST_FILENAME
+ #define TEST_ARRAYS
+
+ 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 = FALSE;
+#else
+ static const bool TEST_INTERACTIVE = FALSE;
+#endif
// ----------------------------------------------------------------------------
// test class for container objects
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());
}
}
}
// 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 },
// VMS file names
{ _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), TRUE, wxPATH_VMS },
printf("ERROR: fullname should be '%s'\n", fni.fullname);
}
- bool isAbsolute = fn.IsAbsolute(fni.format);
+ bool isAbsolute = fn.IsAbsolute();
printf("'%s' is %s (%s)\n\t",
fullname.c_str(),
isAbsolute ? "absolute" : "relative",
}
}
+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.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",
};
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
// ----------------------------------------------------------------------------
gs_cond.Signal();
}
-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("");
}
+class MyWaitingThread : public wxThread
+{
+public:
+ MyWaitingThread(wxCondition *condition)
+ {
+ m_condition = condition;
+
+ Create();
+ }
+
+ virtual ExitCode Entry()
+ {
+ printf("Thread %lu has started running.\n", GetId());
+ fflush(stdout);
+
+ gs_cond.Signal();
+
+ printf("Thread %lu starts to wait...\n", GetId());
+ fflush(stdout);
+
+ m_condition->Wait();
+
+ printf("Thread %lu finished to wait, exiting.\n", GetId());
+ fflush(stdout);
+
+ return 0;
+ }
+
+private:
+ wxCondition *m_condition;
+};
+
+static void TestThreadConditions()
+{
+ wxCondition condition;
+
+ // 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++ )
+ {
+ threads[n] = new MyWaitingThread(&condition);
+ }
+
+ for ( n = 0; n < WXSIZEOF(threads); n++ )
+ {
+ threads[n]->Run();
+ }
+
+ // 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) )
+ {
+ 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);
+}
+
#endif // TEST_THREADS
// ----------------------------------------------------------------------------
#ifdef TEST_ARRAYS
-static void PrintArray(const char* name, const wxArrayString& array)
-{
- printf("Dump of the array '%s'\n", name);
+#include "wx/dynarray.h"
- 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());
- }
-}
+#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 wxArrayInt& array)
+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] = %d\n", name, n, array[n]);
+ printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
}
}
return first.length() - second.length();
}
-int wxCMPFUNC_CONV IntCompare(int *first,
- int *second)
-{
- return *first - *second;
-}
-
-int wxCMPFUNC_CONV IntRevCompare(int *first,
- int *second)
-{
- return *second - *first;
-}
-
-static void TestArrayOfInts()
-{
- puts("*** Testing wxArrayInt ***\n");
-
- wxArrayInt a;
- a.Add(1);
- a.Add(17);
- a.Add(5);
- a.Add(3);
-
- puts("Initially:");
- PrintArray("a", a);
-
- puts("After sort:");
- a.Sort(IntCompare);
- PrintArray("a", a);
-
- puts("After reverse sort:");
- a.Sort(IntRevCompare);
- PrintArray("a", a);
+#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); \
}
-#include "wx/dynarray.h"
-
-WX_DECLARE_OBJARRAY(Bar, ArrayBars);
-#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(ArrayBars);
+TestArrayOf(Short);
+TestArrayOf(Int);
static void TestArrayOfObjects()
{
// 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
- if ( 0 )
+ if ( 1 )
{
wxFileName fn;
fn.Assign("c:\\foo", "bar.baz");
DumpFileName(fn);
}
- if ( 0 )
+ if ( TEST_ALL )
{
- TestFileNameConstruction();
- TestFileNameSplit();
- TestFileNameTemp();
+ 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();
+ 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();
+#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
#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