| OLD | NEW |
|---|
| (Empty) |
| 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 compi
lers 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 calle
d. | |
| 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, UB
ool 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 o
n failure | |
| 267 * @return TRUE on success, FALSE on failure. | |
| 268 */ | |
| 269 UBool assertSuccess(const char* message, UErrorCode ec, UBool possibleDataEr
ror=FALSE, const char *file=NULL, int line=0); | |
| 270 UBool assertEquals(const char* message, const UnicodeString& expected, | |
| 271 const UnicodeString& actual, UBool possibleDataError=FALS
E); | |
| 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& expect
ed, | |
| 289 const UnicodeString& actual, UBool possibleDataError=FALS
E); | |
| 290 UBool assertEquals(const UnicodeString& message, const char* expected, | |
| 291 const char* actual); | |
| 292 UBool assertEquals(const UnicodeString& message, UBool expected, UBool actua
l); | |
| 293 UBool assertEquals(const UnicodeString& message, int32_t expected, int32_t a
ctual); | |
| 294 UBool assertEquals(const UnicodeString& message, int64_t expected, int64_t a
ctual); | |
| 295 | |
| 296 virtual void runIndexedTest( int32_t index, UBool exec, const char* &name, c
har* 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 &t
arget); | |
| 340 static UnicodeString prettify(const UnicodeString &source, UBool parseBacksl
ash=FALSE); | |
| 341 // digits=-1 determines the number of digits automatically | |
| 342 static UnicodeString &appendHex(uint32_t number, int32_t digits, UnicodeStri
ng &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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
