1 /******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 1997-2015, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6 7 8 /** 9 * IntlTest is a base class for tests. */ 10 11 #ifndef _INTLTEST 12 #define _INTLTEST 13 14 // The following includes utypes.h, uobject.h and unistr.h 15 #include "unicode/fmtable.h" 16 #include "unicode/testlog.h" 17 18 19 #if U_NO_DEFAULT_INCLUDE_UTF_HEADERS 20 /* deprecated - make tests pass with U_NO_DEFAULT_INCLUDE_UTF_HEADERS */ 21 #include "unicode/utf_old.h" 22 #endif 23 24 U_NAMESPACE_USE 25 26 #if U_PLATFORM == U_PF_OS390 27 // avoid collision with math.h/log() 28 // this must be after including utypes.h so that U_PLATFORM is actually defined 29 #pragma map(IntlTest::log( const UnicodeString &message ),"logos390") 30 #endif 31 32 //----------------------------------------------------------------------------- 33 //convenience classes to ease porting code that uses the Java 34 //string-concatenation operator (moved from findword test by rtg) 35 UnicodeString UCharToUnicodeString(UChar c); 36 UnicodeString Int64ToUnicodeString(int64_t num); 37 //UnicodeString operator+(const UnicodeString& left, int64_t num); // Some compilers don't allow this because of the long type. 38 UnicodeString operator+(const UnicodeString& left, long num); 39 UnicodeString operator+(const UnicodeString& left, unsigned long num); 40 UnicodeString operator+(const UnicodeString& left, double num); 41 UnicodeString operator+(const UnicodeString& left, char num); 42 UnicodeString operator+(const UnicodeString& left, short num); 43 UnicodeString operator+(const UnicodeString& left, int num); 44 UnicodeString operator+(const UnicodeString& left, unsigned char num); 45 UnicodeString operator+(const UnicodeString& left, unsigned short num); 46 UnicodeString operator+(const UnicodeString& left, unsigned int num); 47 UnicodeString operator+(const UnicodeString& left, float num); 48 #if !UCONFIG_NO_FORMATTING 49 UnicodeString toString(const Formattable& f); // liu 50 UnicodeString toString(int32_t n); 51 #endif 52 UnicodeString toString(UBool b); 53 54 //----------------------------------------------------------------------------- 55 56 // Use the TESTCASE macro in subclasses of IntlTest. Define the 57 // runIndexedTest method in this fashion: 58 // 59 //| void MyTest::runIndexedTest(int32_t index, UBool exec, 60 //| const char* &name, char* /*par*/) { 61 //| switch (index) { 62 //| TESTCASE(0,TestSomething); 63 //| TESTCASE(1,TestSomethingElse); 64 //| TESTCASE(2,TestAnotherThing); 65 //| default: name = ""; break; 66 //| } 67 //| } 68 #define TESTCASE(id,test) \ 69 case id: \ 70 name = #test; \ 71 if (exec) { \ 72 logln(#test "---"); \ 73 logln(); \ 74 test(); \ 75 } \ 76 break 77 78 // More convenient macros. These allow easy reordering of the test cases. 79 // 80 //| void MyTest::runIndexedTest(int32_t index, UBool exec, 81 //| const char* &name, char* /*par*/) { 82 //| TESTCASE_AUTO_BEGIN; 83 //| TESTCASE_AUTO(TestSomething); 84 //| TESTCASE_AUTO(TestSomethingElse); 85 //| TESTCASE_AUTO(TestAnotherThing); 86 //| TESTCASE_AUTO_END; 87 //| } 88 #define TESTCASE_AUTO_BEGIN \ 89 for(;;) { \ 90 int32_t testCaseAutoNumber = 0 91 92 #define TESTCASE_AUTO(test) \ 93 if (index == testCaseAutoNumber++) { \ 94 name = #test; \ 95 if (exec) { \ 96 logln(#test "---"); \ 97 logln(); \ 98 test(); \ 99 } \ 100 break; \ 101 } 102 103 #define TESTCASE_AUTO_CLASS(TestClass) \ 104 if (index == testCaseAutoNumber++) { \ 105 name = #TestClass; \ 106 if (exec) { \ 107 logln(#TestClass "---"); \ 108 logln(); \ 109 TestClass test; \ 110 callTest(test, par); \ 111 } \ 112 break; \ 113 } 114 115 #define TESTCASE_AUTO_CREATE_CLASS(TestClass) \ 116 if (index == testCaseAutoNumber++) { \ 117 name = #TestClass; \ 118 if (exec) { \ 119 logln(#TestClass "---"); \ 120 logln(); \ 121 LocalPointer<IntlTest> test(create##TestClass()); \ 122 callTest(*test, par); \ 123 } \ 124 break; \ 125 } 126 127 #define TESTCASE_AUTO_END \ 128 name = ""; \ 129 break; \ 130 } 131 132 #define TEST_ASSERT_TRUE(x) \ 133 assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__) 134 135 #define TEST_ASSERT_STATUS(x) \ 136 assertSuccess(#x, (x), FALSE, __FILE__, __LINE__) 137 138 class IntlTest : public TestLog { 139 public: 140 141 IntlTest(); 142 // TestLog has a virtual destructor. 143 144 virtual UBool runTest( char* name = NULL, char* par = NULL, char *baseName = NULL); // not to be overidden 145 146 virtual UBool setVerbose( UBool verbose = TRUE ); 147 virtual UBool setNoErrMsg( UBool no_err_msg = TRUE ); 148 virtual UBool setQuick( UBool quick = TRUE ); 149 virtual UBool setLeaks( UBool leaks = TRUE ); 150 virtual UBool setNotime( UBool no_time = TRUE ); 151 virtual UBool setWarnOnMissingData( UBool warn_on_missing_data = TRUE ); 152 virtual int32_t setThreadCount( int32_t count = 1); 153 154 virtual int32_t getErrors( void ); 155 virtual int32_t getDataErrors (void ); 156 157 virtual void setCaller( IntlTest* callingTest ); // for internal use only 158 virtual void setPath( char* path ); // for internal use only 159 160 virtual void log( const UnicodeString &message ); 161 162 virtual void logln( const UnicodeString &message ); 163 164 virtual void logln( void ); 165 166 /** 167 * Replaces isICUVersionAtLeast and isICUVersionBefore 168 * log that an issue is known. 169 * Usually used this way: 170 * <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code> 171 * @param ticket ticket string, "12345" or "cldrbug:1234" 172 * @param message optional message string 173 * @return true if test should be skipped 174 */ 175 UBool logKnownIssue( const char *ticket, const UnicodeString &message ); 176 /** 177 * Replaces isICUVersionAtLeast and isICUVersionBefore 178 * log that an issue is known. 179 * Usually used this way: 180 * <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code> 181 * @param ticket ticket string, "12345" or "cldrbug:1234" 182 * @return true if test should be skipped 183 */ 184 UBool logKnownIssue( const char *ticket ); 185 /** 186 * Replaces isICUVersionAtLeast and isICUVersionBefore 187 * log that an issue is known. 188 * Usually used this way: 189 * <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code> 190 * @param ticket ticket string, "12345" or "cldrbug:1234" 191 * @param message optional message string 192 * @return true if test should be skipped 193 */ 194 UBool logKnownIssue( const char *ticket, const char *fmt, ...); 195 196 virtual void info( const UnicodeString &message ); 197 198 virtual void infoln( const UnicodeString &message ); 199 200 virtual void infoln( void ); 201 202 virtual void err(void); 203 204 virtual void err( const UnicodeString &message ); 205 206 virtual void errln( const UnicodeString &message ); 207 208 virtual void dataerr( const UnicodeString &message ); 209 210 virtual void dataerrln( const UnicodeString &message ); 211 212 void errcheckln(UErrorCode status, const UnicodeString &message ); 213 214 // convenience functions: sprintf() + errln() etc. 215 void log(const char *fmt, ...); 216 void logln(const char *fmt, ...); 217 void info(const char *fmt, ...); 218 void infoln(const char *fmt, ...); 219 void err(const char *fmt, ...); 220 void errln(const char *fmt, ...); 221 void dataerr(const char *fmt, ...); 222 void dataerrln(const char *fmt, ...); 223 224 /** 225 * logs an error (even if status==U_ZERO_ERROR), but 226 * calls dataerrln() or errln() depending on the type of error. 227 * Does not report the status code. 228 * @param status parameter for selecting whether errln or dataerrln is called. 229 */ 230 void errcheckln(UErrorCode status, const char *fmt, ...); 231 232 // Print ALL named errors encountered so far 233 void printErrors(); 234 235 // print known issues. return TRUE if there were any. 236 UBool printKnownIssues(); 237 238 virtual void usage( void ) ; 239 240 /** 241 * Returns a uniform random value x, with 0.0 <= x < 1.0. Use 242 * with care: Does not return all possible values; returns one of 243 * 714,025 values, uniformly spaced. However, the period is 244 * effectively infinite. See: Numerical Recipes, section 7.1. 245 * 246 * @param seedp pointer to seed. Set *seedp to any negative value 247 * to restart the sequence. 248 */ 249 static float random(int32_t* seedp); 250 251 /** 252 * Convenience method using a global seed. 253 */ 254 static float random(); 255 256 enum { kMaxProps = 16 }; 257 258 virtual void setProperty(const char* propline); 259 virtual const char* getProperty(const char* prop); 260 261 protected: 262 /* JUnit-like assertions. Each returns TRUE if it succeeds. */ 263 UBool assertTrue(const char* message, UBool condition, UBool quiet=FALSE, UBool possibleDataError=FALSE, const char *file=NULL, int line=0); 264 UBool assertFalse(const char* message, UBool condition, UBool quiet=FALSE); 265 /** 266 * @param possibleDataError - if TRUE, use dataerrln instead of errcheckln on failure 267 * @return TRUE on success, FALSE on failure. 268 */ 269 UBool assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError=FALSE, const char *file=NULL, int line=0); 270 UBool assertEquals(const char* message, const UnicodeString& expected, 271 const UnicodeString& actual, UBool possibleDataError=FALSE); 272 UBool assertEquals(const char* message, const char* expected, 273 const char* actual); 274 UBool assertEquals(const char* message, UBool expected, 275 UBool actual); 276 UBool assertEquals(const char* message, int32_t expected, int32_t actual); 277 UBool assertEquals(const char* message, int64_t expected, int64_t actual); 278 UBool assertEquals(const char* message, double expected, double actual); 279 #if !UCONFIG_NO_FORMATTING 280 UBool assertEquals(const char* message, const Formattable& expected, 281 const Formattable& actual, UBool possibleDataError=FALSE); 282 UBool assertEquals(const UnicodeString& message, const Formattable& expected, 283 const Formattable& actual); 284 #endif 285 UBool assertTrue(const UnicodeString& message, UBool condition, UBool quiet=FALSE); 286 UBool assertFalse(const UnicodeString& message, UBool condition, UBool quiet=FALSE); 287 UBool assertSuccess(const UnicodeString& message, UErrorCode ec); 288 UBool assertEquals(const UnicodeString& message, const UnicodeString& expected, 289 const UnicodeString& actual, UBool possibleDataError=FALSE); 290 UBool assertEquals(const UnicodeString& message, const char* expected, 291 const char* actual); 292 UBool assertEquals(const UnicodeString& message, UBool expected, UBool actual); 293 UBool assertEquals(const UnicodeString& message, int32_t expected, int32_t actual); 294 UBool assertEquals(const UnicodeString& message, int64_t expected, int64_t actual); 295 296 virtual void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL ); // overide ! 297 298 virtual UBool runTestLoop( char* testname, char* par, char *baseName ); 299 300 virtual int32_t IncErrorCount( void ); 301 302 virtual int32_t IncDataErrorCount( void ); 303 304 virtual UBool callTest( IntlTest& testToBeCalled, char* par ); 305 306 307 UBool verbose; 308 UBool no_err_msg; 309 UBool quick; 310 UBool leaks; 311 UBool warn_on_missing_data; 312 UBool no_time; 313 int32_t threadCount; 314 315 private: 316 UBool LL_linestart; 317 int32_t LL_indentlevel; 318 319 int32_t errorCount; 320 int32_t dataErrorCount; 321 IntlTest* caller; 322 char* testPath; // specifies subtests 323 324 char basePath[1024]; 325 char currName[1024]; // current test name 326 327 //FILE *testoutfp; 328 void *testoutfp; 329 330 const char* proplines[kMaxProps]; 331 int32_t numProps; 332 333 protected: 334 335 virtual void LL_message( UnicodeString message, UBool newline ); 336 337 // used for collation result reporting, defined here for convenience 338 339 static UnicodeString &prettify(const UnicodeString &source, UnicodeString &target); 340 static UnicodeString prettify(const UnicodeString &source, UBool parseBackslash=FALSE); 341 // digits=-1 determines the number of digits automatically 342 static UnicodeString &appendHex(uint32_t number, int32_t digits, UnicodeString &target); 343 static UnicodeString toHex(uint32_t number, int32_t digits=-1); 344 static inline UnicodeString toHex(int32_t number, int32_t digits=-1) { 345 return toHex((uint32_t)number, digits); 346 } 347 348 public: 349 static void setICU_DATA(); // Set up ICU_DATA if necessary. 350 351 static const char* pathToDataDirectory(); 352 353 public: 354 UBool run_phase2( char* name, char* par ); // internally, supports reporting memory leaks 355 static const char* loadTestData(UErrorCode& err); 356 virtual const char* getTestDataPath(UErrorCode& err); 357 static const char* getSourceTestData(UErrorCode& err); 358 static char *getUnidataPath(char path[]); 359 360 // static members 361 public: 362 static IntlTest* gTest; 363 static const char* fgDataDir; 364 365 }; 366 367 void it_log( UnicodeString message ); 368 void it_logln( UnicodeString message ); 369 void it_logln( void ); 370 void it_info( UnicodeString message ); 371 void it_infoln( UnicodeString message ); 372 void it_infoln( void ); 373 void it_err(void); 374 void it_err( UnicodeString message ); 375 void it_errln( UnicodeString message ); 376 void it_dataerr( UnicodeString message ); 377 void it_dataerrln( UnicodeString message ); 378 379 /** 380 * This is a variant of cintltst/ccolltst.c:CharsToUChars(). 381 * It converts a character string into a UnicodeString, with 382 * unescaping \u sequences. 383 */ 384 extern UnicodeString CharsToUnicodeString(const char* chars); 385 386 /* alias for CharsToUnicodeString */ 387 extern UnicodeString ctou(const char* chars); 388 389 #endif // _INTLTEST 390
