1 /********************************************************************
3 * Copyright (c) 1997-2014, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
9 * IntlTest is a base class for tests. */
14 // The following includes utypes.h, uobject.h and unistr.h
15 #include "unicode/fmtable.h"
16 #include "unicode/testlog.h"
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"
25 * \def ICU_USE_THREADS
27 * Enables multi-threaded testing. Moved here from uconfig.h.
30 * This switch used to allow thread support (use of mutexes) to be compiled out of ICU.
32 #ifdef ICU_USE_THREADS
33 /* Use the predefined value. */
34 #elif defined(APP_NO_THREADS)
35 /* APP_NO_THREADS is an old symbol. We'll honour it if present. */
36 # define ICU_USE_THREADS 0
38 # define ICU_USE_THREADS 1
43 #if U_PLATFORM == U_PF_OS390
44 // avoid collision with math.h/log()
45 // this must be after including utypes.h so that U_PLATFORM is actually defined
46 #pragma map(IntlTest::log( const UnicodeString &message ),"logos390")
49 //-----------------------------------------------------------------------------
50 //convenience classes to ease porting code that uses the Java
51 //string-concatenation operator (moved from findword test by rtg)
52 UnicodeString
UCharToUnicodeString(UChar c
);
53 UnicodeString
Int64ToUnicodeString(int64_t num
);
54 //UnicodeString operator+(const UnicodeString& left, int64_t num); // Some compilers don't allow this because of the long type.
55 UnicodeString
operator+(const UnicodeString
& left
, long num
);
56 UnicodeString
operator+(const UnicodeString
& left
, unsigned long num
);
57 UnicodeString
operator+(const UnicodeString
& left
, double num
);
58 UnicodeString
operator+(const UnicodeString
& left
, char num
);
59 UnicodeString
operator+(const UnicodeString
& left
, short num
);
60 UnicodeString
operator+(const UnicodeString
& left
, int num
);
61 UnicodeString
operator+(const UnicodeString
& left
, unsigned char num
);
62 UnicodeString
operator+(const UnicodeString
& left
, unsigned short num
);
63 UnicodeString
operator+(const UnicodeString
& left
, unsigned int num
);
64 UnicodeString
operator+(const UnicodeString
& left
, float num
);
65 #if !UCONFIG_NO_FORMATTING
66 UnicodeString
toString(const Formattable
& f
); // liu
67 UnicodeString
toString(int32_t n
);
69 UnicodeString
toString(UBool b
);
71 //-----------------------------------------------------------------------------
73 // Use the TESTCASE macro in subclasses of IntlTest. Define the
74 // runIndexedTest method in this fashion:
76 //| void MyTest::runIndexedTest(int32_t index, UBool exec,
77 //| const char* &name, char* /*par*/) {
79 //| TESTCASE(0,TestSomething);
80 //| TESTCASE(1,TestSomethingElse);
81 //| TESTCASE(2,TestAnotherThing);
82 //| default: name = ""; break;
85 #define TESTCASE(id,test) \
95 // More convenient macros. These allow easy reordering of the test cases.
97 //| void MyTest::runIndexedTest(int32_t index, UBool exec,
98 //| const char* &name, char* /*par*/) {
99 //| TESTCASE_AUTO_BEGIN;
100 //| TESTCASE_AUTO(TestSomething);
101 //| TESTCASE_AUTO(TestSomethingElse);
102 //| TESTCASE_AUTO(TestAnotherThing);
103 //| TESTCASE_AUTO_END;
105 #define TESTCASE_AUTO_BEGIN \
107 int32_t testCaseAutoNumber = 0
109 #define TESTCASE_AUTO(test) \
110 if (index == testCaseAutoNumber++) { \
113 logln(#test "---"); \
120 #define TESTCASE_AUTO_CLASS(TestClass) \
121 if (index == testCaseAutoNumber++) { \
124 logln(#TestClass "---"); \
127 callTest(test, par); \
132 #define TESTCASE_AUTO_CREATE_CLASS(TestClass) \
133 if (index == testCaseAutoNumber++) { \
136 logln(#TestClass "---"); \
138 LocalPointer<IntlTest> test(create##TestClass()); \
139 callTest(*test, par); \
144 #define TESTCASE_AUTO_END \
149 #define TEST_ASSERT_TRUE(x) \
150 assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__)
152 #define TEST_ASSERT_STATUS(x) \
153 assertSuccess(#x, (x), FALSE, __FILE__, __LINE__)
155 class IntlTest
: public TestLog
{
159 // TestLog has a virtual destructor.
161 virtual UBool
runTest( char* name
= NULL
, char* par
= NULL
, char *baseName
= NULL
); // not to be overidden
163 virtual UBool
setVerbose( UBool verbose
= TRUE
);
164 virtual UBool
setNoErrMsg( UBool no_err_msg
= TRUE
);
165 virtual UBool
setQuick( UBool quick
= TRUE
);
166 virtual UBool
setLeaks( UBool leaks
= TRUE
);
167 virtual UBool
setNotime( UBool no_time
= TRUE
);
168 virtual UBool
setWarnOnMissingData( UBool warn_on_missing_data
= TRUE
);
169 virtual int32_t setThreadCount( int32_t count
= 1);
171 virtual int32_t getErrors( void );
172 virtual int32_t getDataErrors (void );
174 virtual void setCaller( IntlTest
* callingTest
); // for internal use only
175 virtual void setPath( char* path
); // for internal use only
177 virtual void log( const UnicodeString
&message
);
179 virtual void logln( const UnicodeString
&message
);
181 virtual void logln( void );
184 * Replaces isICUVersionAtLeast and isICUVersionBefore
185 * log that an issue is known.
186 * Usually used this way:
187 * <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code>
188 * @param ticket ticket string, "12345" or "cldrbug:1234"
189 * @param message optional message string
190 * @return true if test should be skipped
192 UBool
logKnownIssue( const char *ticket
, const UnicodeString
&message
);
194 * Replaces isICUVersionAtLeast and isICUVersionBefore
195 * log that an issue is known.
196 * Usually used this way:
197 * <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code>
198 * @param ticket ticket string, "12345" or "cldrbug:1234"
199 * @return true if test should be skipped
201 UBool
logKnownIssue( const char *ticket
);
203 * Replaces isICUVersionAtLeast and isICUVersionBefore
204 * log that an issue is known.
205 * Usually used this way:
206 * <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code>
207 * @param ticket ticket string, "12345" or "cldrbug:1234"
208 * @param message optional message string
209 * @return true if test should be skipped
211 UBool
logKnownIssue( const char *ticket
, const char *fmt
, ...);
213 virtual void info( const UnicodeString
&message
);
215 virtual void infoln( const UnicodeString
&message
);
217 virtual void infoln( void );
219 virtual void err(void);
221 virtual void err( const UnicodeString
&message
);
223 virtual void errln( const UnicodeString
&message
);
225 virtual void dataerr( const UnicodeString
&message
);
227 virtual void dataerrln( const UnicodeString
&message
);
229 void errcheckln(UErrorCode status
, const UnicodeString
&message
);
231 // convenience functions: sprintf() + errln() etc.
232 void log(const char *fmt
, ...);
233 void logln(const char *fmt
, ...);
234 void info(const char *fmt
, ...);
235 void infoln(const char *fmt
, ...);
236 void err(const char *fmt
, ...);
237 void errln(const char *fmt
, ...);
238 void dataerr(const char *fmt
, ...);
239 void dataerrln(const char *fmt
, ...);
242 * logs an error (even if status==U_ZERO_ERROR), but
243 * calls dataerrln() or errln() depending on the type of error.
244 * Does not report the status code.
245 * @param status parameter for selecting whether errln or dataerrln is called.
247 void errcheckln(UErrorCode status
, const char *fmt
, ...);
249 // Print ALL named errors encountered so far
252 // print known issues. return TRUE if there were any.
253 UBool
printKnownIssues();
255 virtual void usage( void ) ;
258 * Returns a uniform random value x, with 0.0 <= x < 1.0. Use
259 * with care: Does not return all possible values; returns one of
260 * 714,025 values, uniformly spaced. However, the period is
261 * effectively infinite. See: Numerical Recipes, section 7.1.
263 * @param seedp pointer to seed. Set *seedp to any negative value
264 * to restart the sequence.
266 static float random(int32_t* seedp
);
269 * Convenience method using a global seed.
271 static float random();
273 enum { kMaxProps
= 16 };
275 virtual void setProperty(const char* propline
);
276 virtual const char* getProperty(const char* prop
);
279 /* JUnit-like assertions. Each returns TRUE if it succeeds. */
280 UBool
assertTrue(const char* message
, UBool condition
, UBool quiet
=FALSE
, UBool possibleDataError
=FALSE
, const char *file
=NULL
, int line
=0);
281 UBool
assertFalse(const char* message
, UBool condition
, UBool quiet
=FALSE
);
283 * @param possibleDataError - if TRUE, use dataerrln instead of errcheckln on failure
284 * @return TRUE on success, FALSE on failure.
286 UBool
assertSuccess(const char* message
, UErrorCode ec
, UBool possibleDataError
=FALSE
, const char *file
=NULL
, int line
=0);
287 UBool
assertEquals(const char* message
, const UnicodeString
& expected
,
288 const UnicodeString
& actual
, UBool possibleDataError
=FALSE
);
289 UBool
assertEquals(const char* message
, const char* expected
,
291 UBool
assertEquals(const char* message
, UBool expected
,
293 UBool
assertEquals(const char* message
, int32_t expected
, int32_t actual
);
294 UBool
assertEquals(const char* message
, int64_t expected
, int64_t actual
);
295 #if !UCONFIG_NO_FORMATTING
296 UBool
assertEquals(const char* message
, const Formattable
& expected
,
297 const Formattable
& actual
, UBool possibleDataError
=FALSE
);
298 UBool
assertEquals(const UnicodeString
& message
, const Formattable
& expected
,
299 const Formattable
& actual
);
301 UBool
assertTrue(const UnicodeString
& message
, UBool condition
, UBool quiet
=FALSE
);
302 UBool
assertFalse(const UnicodeString
& message
, UBool condition
, UBool quiet
=FALSE
);
303 UBool
assertSuccess(const UnicodeString
& message
, UErrorCode ec
);
304 UBool
assertEquals(const UnicodeString
& message
, const UnicodeString
& expected
,
305 const UnicodeString
& actual
, UBool possibleDataError
=FALSE
);
306 UBool
assertEquals(const UnicodeString
& message
, const char* expected
,
308 UBool
assertEquals(const UnicodeString
& message
, UBool expected
, UBool actual
);
309 UBool
assertEquals(const UnicodeString
& message
, int32_t expected
, int32_t actual
);
310 UBool
assertEquals(const UnicodeString
& message
, int64_t expected
, int64_t actual
);
312 virtual void runIndexedTest( int32_t index
, UBool exec
, const char* &name
, char* par
= NULL
); // overide !
314 virtual UBool
runTestLoop( char* testname
, char* par
, char *baseName
);
316 virtual int32_t IncErrorCount( void );
318 virtual int32_t IncDataErrorCount( void );
320 virtual UBool
callTest( IntlTest
& testToBeCalled
, char* par
);
327 UBool warn_on_missing_data
;
333 int32_t LL_indentlevel
;
336 int32_t dataErrorCount
;
338 char* testPath
; // specifies subtests
341 char currName
[1024]; // current test name
346 const char* proplines
[kMaxProps
];
351 virtual void LL_message( UnicodeString message
, UBool newline
);
353 // used for collation result reporting, defined here for convenience
355 static UnicodeString
&prettify(const UnicodeString
&source
, UnicodeString
&target
);
356 static UnicodeString
prettify(const UnicodeString
&source
, UBool parseBackslash
=FALSE
);
357 // digits=-1 determines the number of digits automatically
358 static UnicodeString
&appendHex(uint32_t number
, int32_t digits
, UnicodeString
&target
);
359 static UnicodeString
toHex(uint32_t number
, int32_t digits
=-1);
360 static inline UnicodeString
toHex(int32_t number
, int32_t digits
=-1) {
361 return toHex((uint32_t)number
, digits
);
365 static void setICU_DATA(); // Set up ICU_DATA if necessary.
367 static const char* pathToDataDirectory();
370 UBool
run_phase2( char* name
, char* par
); // internally, supports reporting memory leaks
371 static const char* loadTestData(UErrorCode
& err
);
372 virtual const char* getTestDataPath(UErrorCode
& err
);
373 static const char* getSourceTestData(UErrorCode
& err
);
377 static IntlTest
* gTest
;
378 static const char* fgDataDir
;
382 void it_log( UnicodeString message
);
383 void it_logln( UnicodeString message
);
384 void it_logln( void );
385 void it_info( UnicodeString message
);
386 void it_infoln( UnicodeString message
);
387 void it_infoln( void );
389 void it_err( UnicodeString message
);
390 void it_errln( UnicodeString message
);
391 void it_dataerr( UnicodeString message
);
392 void it_dataerrln( UnicodeString message
);
395 * This is a variant of cintltst/ccolltst.c:CharsToUChars().
396 * It converts a character string into a UnicodeString, with
397 * unescaping \u sequences.
399 extern UnicodeString
CharsToUnicodeString(const char* chars
);
401 /* alias for CharsToUnicodeString */
402 extern UnicodeString
ctou(const char* chars
);