X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/b75a7d8f3b4adbae880cab104ce2c6a50eee4db2..57a6839dcb3bba09e8228b822b290604668416fe:/icuSources/test/intltest/intltest.h?ds=inline diff --git a/icuSources/test/intltest/intltest.h b/icuSources/test/intltest/intltest.h index 940dbe54..4e78ec5c 100644 --- a/icuSources/test/intltest/intltest.h +++ b/icuSources/test/intltest/intltest.h @@ -1,6 +1,6 @@ /******************************************************************** * COPYRIGHT: - * Copyright (c) 1997-2003, International Business Machines Corporation and + * Copyright (c) 1997-2014, International Business Machines Corporation and * others. All Rights Reserved. ********************************************************************/ @@ -11,40 +11,63 @@ #ifndef _INTLTEST #define _INTLTEST -#include - -#include "unicode/utypes.h" -#include "unicode/unistr.h" +// The following includes utypes.h, uobject.h and unistr.h #include "unicode/fmtable.h" +#include "unicode/testlog.h" + + +#if U_NO_DEFAULT_INCLUDE_UTF_HEADERS +/* deprecated - make tests pass with U_NO_DEFAULT_INCLUDE_UTF_HEADERS */ +#include "unicode/utf_old.h" +#endif + +/** + * \def ICU_USE_THREADS + * + * Enables multi-threaded testing. Moved here from uconfig.h. + * Default: enabled + * + * This switch used to allow thread support (use of mutexes) to be compiled out of ICU. + */ +#ifdef ICU_USE_THREADS + /* Use the predefined value. */ +#elif defined(APP_NO_THREADS) + /* APP_NO_THREADS is an old symbol. We'll honour it if present. */ +# define ICU_USE_THREADS 0 +#else +# define ICU_USE_THREADS 1 +#endif U_NAMESPACE_USE -#ifdef OS390 +#if U_PLATFORM == U_PF_OS390 // avoid collision with math.h/log() -// this must be after including utypes.h so that OS390 is actually defined +// this must be after including utypes.h so that U_PLATFORM is actually defined #pragma map(IntlTest::log( const UnicodeString &message ),"logos390") #endif -#define it_out (*IntlTest::gTest) - //----------------------------------------------------------------------------- //convenience classes to ease porting code that uses the Java //string-concatenation operator (moved from findword test by rtg) UnicodeString UCharToUnicodeString(UChar c); -UnicodeString operator+(const UnicodeString& left, const UnicodeString& right); +UnicodeString Int64ToUnicodeString(int64_t num); +//UnicodeString operator+(const UnicodeString& left, int64_t num); // Some compilers don't allow this because of the long type. UnicodeString operator+(const UnicodeString& left, long num); UnicodeString operator+(const UnicodeString& left, unsigned long num); UnicodeString operator+(const UnicodeString& left, double num); -UnicodeString operator+(const UnicodeString& left, char num); -UnicodeString operator+(const UnicodeString& left, short num); -UnicodeString operator+(const UnicodeString& left, int num); -UnicodeString operator+(const UnicodeString& left, unsigned char num); -UnicodeString operator+(const UnicodeString& left, unsigned short num); -UnicodeString operator+(const UnicodeString& left, unsigned int num); +UnicodeString operator+(const UnicodeString& left, char num); +UnicodeString operator+(const UnicodeString& left, short num); +UnicodeString operator+(const UnicodeString& left, int num); +UnicodeString operator+(const UnicodeString& left, unsigned char num); +UnicodeString operator+(const UnicodeString& left, unsigned short num); +UnicodeString operator+(const UnicodeString& left, unsigned int num); UnicodeString operator+(const UnicodeString& left, float num); #if !UCONFIG_NO_FORMATTING UnicodeString toString(const Formattable& f); // liu +UnicodeString toString(int32_t n); #endif +UnicodeString toString(UBool b); + //----------------------------------------------------------------------------- // Use the TESTCASE macro in subclasses of IntlTest. Define the @@ -64,24 +87,89 @@ UnicodeString toString(const Formattable& f); // liu name = #test; \ if (exec) { \ logln(#test "---"); \ - logln((UnicodeString)""); \ + logln(); \ test(); \ } \ break -class IntlTest { +// More convenient macros. These allow easy reordering of the test cases. +// +//| void MyTest::runIndexedTest(int32_t index, UBool exec, +//| const char* &name, char* /*par*/) { +//| TESTCASE_AUTO_BEGIN; +//| TESTCASE_AUTO(TestSomething); +//| TESTCASE_AUTO(TestSomethingElse); +//| TESTCASE_AUTO(TestAnotherThing); +//| TESTCASE_AUTO_END; +//| } +#define TESTCASE_AUTO_BEGIN \ + for(;;) { \ + int32_t testCaseAutoNumber = 0 + +#define TESTCASE_AUTO(test) \ + if (index == testCaseAutoNumber++) { \ + name = #test; \ + if (exec) { \ + logln(#test "---"); \ + logln(); \ + test(); \ + } \ + break; \ + } + +#define TESTCASE_AUTO_CLASS(TestClass) \ + if (index == testCaseAutoNumber++) { \ + name = #TestClass; \ + if (exec) { \ + logln(#TestClass "---"); \ + logln(); \ + TestClass test; \ + callTest(test, par); \ + } \ + break; \ + } + +#define TESTCASE_AUTO_CREATE_CLASS(TestClass) \ + if (index == testCaseAutoNumber++) { \ + name = #TestClass; \ + if (exec) { \ + logln(#TestClass "---"); \ + logln(); \ + LocalPointer test(create##TestClass()); \ + callTest(*test, par); \ + } \ + break; \ + } + +#define TESTCASE_AUTO_END \ + name = ""; \ + break; \ + } + +#define TEST_ASSERT_TRUE(x) \ + assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__) + +#define TEST_ASSERT_STATUS(x) \ + assertSuccess(#x, (x), FALSE, __FILE__, __LINE__) + +class IntlTest : public TestLog { public: IntlTest(); + // TestLog has a virtual destructor. - virtual UBool runTest( char* name = NULL, char* par = NULL ); // not to be overidden + virtual UBool runTest( char* name = NULL, char* par = NULL, char *baseName = NULL); // not to be overidden virtual UBool setVerbose( UBool verbose = TRUE ); virtual UBool setNoErrMsg( UBool no_err_msg = TRUE ); virtual UBool setQuick( UBool quick = TRUE ); virtual UBool setLeaks( UBool leaks = TRUE ); + virtual UBool setNotime( UBool no_time = TRUE ); + virtual UBool setWarnOnMissingData( UBool warn_on_missing_data = TRUE ); + virtual int32_t setThreadCount( int32_t count = 1); virtual int32_t getErrors( void ); + virtual int32_t getDataErrors (void ); virtual void setCaller( IntlTest* callingTest ); // for internal use only virtual void setPath( char* path ); // for internal use only @@ -92,6 +180,36 @@ public: virtual void logln( void ); + /** + * Replaces isICUVersionAtLeast and isICUVersionBefore + * log that an issue is known. + * Usually used this way: + * if( ... && logKnownIssue("12345", "some bug")) continue; + * @param ticket ticket string, "12345" or "cldrbug:1234" + * @param message optional message string + * @return true if test should be skipped + */ + UBool logKnownIssue( const char *ticket, const UnicodeString &message ); + /** + * Replaces isICUVersionAtLeast and isICUVersionBefore + * log that an issue is known. + * Usually used this way: + * if( ... && logKnownIssue("12345", "some bug")) continue; + * @param ticket ticket string, "12345" or "cldrbug:1234" + * @return true if test should be skipped + */ + UBool logKnownIssue( const char *ticket ); + /** + * Replaces isICUVersionAtLeast and isICUVersionBefore + * log that an issue is known. + * Usually used this way: + * if( ... && logKnownIssue("12345", "some bug")) continue; + * @param ticket ticket string, "12345" or "cldrbug:1234" + * @param message optional message string + * @return true if test should be skipped + */ + UBool logKnownIssue( const char *ticket, const char *fmt, ...); + virtual void info( const UnicodeString &message ); virtual void infoln( const UnicodeString &message ); @@ -99,11 +217,17 @@ public: virtual void infoln( void ); virtual void err(void); - + virtual void err( const UnicodeString &message ); virtual void errln( const UnicodeString &message ); + virtual void dataerr( const UnicodeString &message ); + + virtual void dataerrln( const UnicodeString &message ); + + void errcheckln(UErrorCode status, const UnicodeString &message ); + // convenience functions: sprintf() + errln() etc. void log(const char *fmt, ...); void logln(const char *fmt, ...); @@ -111,49 +235,131 @@ public: void infoln(const char *fmt, ...); void err(const char *fmt, ...); void errln(const char *fmt, ...); + void dataerr(const char *fmt, ...); + void dataerrln(const char *fmt, ...); + + /** + * logs an error (even if status==U_ZERO_ERROR), but + * calls dataerrln() or errln() depending on the type of error. + * Does not report the status code. + * @param status parameter for selecting whether errln or dataerrln is called. + */ + void errcheckln(UErrorCode status, const char *fmt, ...); // Print ALL named errors encountered so far void printErrors(); + + // print known issues. return TRUE if there were any. + UBool printKnownIssues(); virtual void usage( void ) ; - FILE *testoutfp; + /** + * Returns a uniform random value x, with 0.0 <= x < 1.0. Use + * with care: Does not return all possible values; returns one of + * 714,025 values, uniformly spaced. However, the period is + * effectively infinite. See: Numerical Recipes, section 7.1. + * + * @param seedp pointer to seed. Set *seedp to any negative value + * to restart the sequence. + */ + static float random(int32_t* seedp); + + /** + * Convenience method using a global seed. + */ + static float random(); + + enum { kMaxProps = 16 }; + + virtual void setProperty(const char* propline); + virtual const char* getProperty(const char* prop); protected: + /* JUnit-like assertions. Each returns TRUE if it succeeds. */ + UBool assertTrue(const char* message, UBool condition, UBool quiet=FALSE, UBool possibleDataError=FALSE, const char *file=NULL, int line=0); + UBool assertFalse(const char* message, UBool condition, UBool quiet=FALSE); + /** + * @param possibleDataError - if TRUE, use dataerrln instead of errcheckln on failure + * @return TRUE on success, FALSE on failure. + */ + UBool assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError=FALSE, const char *file=NULL, int line=0); + UBool assertEquals(const char* message, const UnicodeString& expected, + const UnicodeString& actual, UBool possibleDataError=FALSE); + UBool assertEquals(const char* message, const char* expected, + const char* actual); + UBool assertEquals(const char* message, UBool expected, + UBool actual); + UBool assertEquals(const char* message, int32_t expected, int32_t actual); + UBool assertEquals(const char* message, int64_t expected, int64_t actual); +#if !UCONFIG_NO_FORMATTING + UBool assertEquals(const char* message, const Formattable& expected, + const Formattable& actual, UBool possibleDataError=FALSE); + UBool assertEquals(const UnicodeString& message, const Formattable& expected, + const Formattable& actual); +#endif + UBool assertTrue(const UnicodeString& message, UBool condition, UBool quiet=FALSE); + UBool assertFalse(const UnicodeString& message, UBool condition, UBool quiet=FALSE); + UBool assertSuccess(const UnicodeString& message, UErrorCode ec); + UBool assertEquals(const UnicodeString& message, const UnicodeString& expected, + const UnicodeString& actual, UBool possibleDataError=FALSE); + UBool assertEquals(const UnicodeString& message, const char* expected, + const char* actual); + UBool assertEquals(const UnicodeString& message, UBool expected, UBool actual); + UBool assertEquals(const UnicodeString& message, int32_t expected, int32_t actual); + UBool assertEquals(const UnicodeString& message, int64_t expected, int64_t actual); + virtual void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL ); // overide ! - virtual UBool runTestLoop( char* testname, char* par ); + virtual UBool runTestLoop( char* testname, char* par, char *baseName ); virtual int32_t IncErrorCount( void ); + virtual int32_t IncDataErrorCount( void ); + virtual UBool callTest( IntlTest& testToBeCalled, char* par ); - UBool verbose; - UBool no_err_msg; - UBool quick; - UBool leaks; + UBool verbose; + UBool no_err_msg; + UBool quick; + UBool leaks; + UBool warn_on_missing_data; + UBool no_time; + int32_t threadCount; private: - UBool LL_linestart; + UBool LL_linestart; int32_t LL_indentlevel; int32_t errorCount; + int32_t dataErrorCount; IntlTest* caller; - char* path; // specifies subtests + char* testPath; // specifies subtests + + char basePath[1024]; + char currName[1024]; // current test name + + //FILE *testoutfp; + void *testoutfp; + + const char* proplines[kMaxProps]; + int32_t numProps; protected: + virtual void LL_message( UnicodeString message, UBool newline ); // used for collation result reporting, defined here for convenience static UnicodeString &prettify(const UnicodeString &source, UnicodeString &target); static UnicodeString prettify(const UnicodeString &source, UBool parseBackslash=FALSE); + // digits=-1 determines the number of digits automatically static UnicodeString &appendHex(uint32_t number, int32_t digits, UnicodeString &target); - - /* complete a relative path to a full pathname, and convert to platform-specific syntax. */ - /* The character seperating directories for the relative path is '|'. */ - static void pathnameInContext( char* fullname, int32_t maxsize, const char* relpath ); + static UnicodeString toHex(uint32_t number, int32_t digits=-1); + static inline UnicodeString toHex(int32_t number, int32_t digits=-1) { + return toHex((uint32_t)number, digits); + } public: static void setICU_DATA(); // Set up ICU_DATA if necessary. @@ -163,6 +369,8 @@ public: public: UBool run_phase2( char* name, char* par ); // internally, supports reporting memory leaks static const char* loadTestData(UErrorCode& err); + virtual const char* getTestDataPath(UErrorCode& err); + static const char* getSourceTestData(UErrorCode& err); // static members public: @@ -180,13 +388,8 @@ void it_infoln( void ); void it_err(void); void it_err( UnicodeString message ); void it_errln( UnicodeString message ); - -IntlTest& operator<<(IntlTest& test, const UnicodeString& string); -IntlTest& operator<<(IntlTest& test, const char* string); -IntlTest& operator<<(IntlTest& test, const int32_t num); - -IntlTest& endl( IntlTest& test ); -IntlTest& operator<<(IntlTest& test, IntlTest& ( * _f)(IntlTest&)); +void it_dataerr( UnicodeString message ); +void it_dataerrln( UnicodeString message ); /** * This is a variant of cintltst/ccolltst.c:CharsToUChars(). @@ -195,4 +398,7 @@ IntlTest& operator<<(IntlTest& test, IntlTest& ( * _f)(IntlTest&)); */ extern UnicodeString CharsToUnicodeString(const char* chars); +/* alias for CharsToUnicodeString */ +extern UnicodeString ctou(const char* chars); + #endif // _INTLTEST