1 /********************************************************************
3 * Copyright (c) 1997-2013, 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 //-----------------------------------------------------------------------------
71 // Use the TESTCASE macro in subclasses of IntlTest. Define the
72 // runIndexedTest method in this fashion:
74 //| void MyTest::runIndexedTest(int32_t index, UBool exec,
75 //| const char* &name, char* /*par*/) {
77 //| TESTCASE(0,TestSomething);
78 //| TESTCASE(1,TestSomethingElse);
79 //| TESTCASE(2,TestAnotherThing);
80 //| default: name = ""; break;
83 #define TESTCASE(id,test) \
93 // More convenient macros. These allow easy reordering of the test cases.
95 //| void MyTest::runIndexedTest(int32_t index, UBool exec,
96 //| const char* &name, char* /*par*/) {
97 //| TESTCASE_AUTO_BEGIN;
98 //| TESTCASE_AUTO(TestSomething);
99 //| TESTCASE_AUTO(TestSomethingElse);
100 //| TESTCASE_AUTO(TestAnotherThing);
101 //| TESTCASE_AUTO_END;
103 #define TESTCASE_AUTO_BEGIN \
105 int32_t testCaseAutoNumber = 0
107 #define TESTCASE_AUTO(test) \
108 if (index == testCaseAutoNumber++) { \
111 logln(#test "---"); \
118 #define TESTCASE_AUTO_END \
123 #define TEST_ASSERT_TRUE(x) \
124 assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__)
126 class IntlTest
: public TestLog
{
130 // TestLog has a virtual destructor.
132 virtual UBool
runTest( char* name
= NULL
, char* par
= NULL
, char *baseName
= NULL
); // not to be overidden
134 virtual UBool
setVerbose( UBool verbose
= TRUE
);
135 virtual UBool
setNoErrMsg( UBool no_err_msg
= TRUE
);
136 virtual UBool
setQuick( UBool quick
= TRUE
);
137 virtual UBool
setLeaks( UBool leaks
= TRUE
);
138 virtual UBool
setNotime( UBool no_time
= TRUE
);
139 virtual UBool
setWarnOnMissingData( UBool warn_on_missing_data
= TRUE
);
140 virtual int32_t setThreadCount( int32_t count
= 1);
142 virtual int32_t getErrors( void );
143 virtual int32_t getDataErrors (void );
145 virtual void setCaller( IntlTest
* callingTest
); // for internal use only
146 virtual void setPath( char* path
); // for internal use only
148 virtual void log( const UnicodeString
&message
);
150 virtual void logln( const UnicodeString
&message
);
152 virtual void logln( void );
154 virtual void info( const UnicodeString
&message
);
156 virtual void infoln( const UnicodeString
&message
);
158 virtual void infoln( void );
160 virtual void err(void);
162 virtual void err( const UnicodeString
&message
);
164 virtual void errln( const UnicodeString
&message
);
166 virtual void dataerr( const UnicodeString
&message
);
168 virtual void dataerrln( const UnicodeString
&message
);
170 void errcheckln(UErrorCode status
, const UnicodeString
&message
);
172 // convenience functions: sprintf() + errln() etc.
173 void log(const char *fmt
, ...);
174 void logln(const char *fmt
, ...);
175 void info(const char *fmt
, ...);
176 void infoln(const char *fmt
, ...);
177 void err(const char *fmt
, ...);
178 void errln(const char *fmt
, ...);
179 void dataerr(const char *fmt
, ...);
180 void dataerrln(const char *fmt
, ...);
181 void errcheckln(UErrorCode status
, const char *fmt
, ...);
183 // Print ALL named errors encountered so far
186 virtual void usage( void ) ;
189 * Returns a uniform random value x, with 0.0 <= x < 1.0. Use
190 * with care: Does not return all possible values; returns one of
191 * 714,025 values, uniformly spaced. However, the period is
192 * effectively infinite. See: Numerical Recipes, section 7.1.
194 * @param seedp pointer to seed. Set *seedp to any negative value
195 * to restart the sequence.
197 static float random(int32_t* seedp
);
200 * Convenience method using a global seed.
202 static float random();
205 * Returns true if u_getVersion() < major.minor.
207 static UBool
isICUVersionBefore(int major
, int minor
) {
208 return isICUVersionBefore(major
, minor
, 0);
212 * Returns true if u_getVersion() < major.minor.milli.
214 static UBool
isICUVersionBefore(int major
, int minor
, int milli
);
217 * Returns true if u_getVersion() >= major.minor.
219 static UBool
isICUVersionAtLeast(int major
, int minor
) {
220 return isICUVersionAtLeast(major
, minor
, 0);
224 * Returns true if u_getVersion() >= major.minor.milli.
226 static UBool
isICUVersionAtLeast(int major
, int minor
, int milli
) {
227 return !isICUVersionBefore(major
, minor
, milli
);
230 enum { kMaxProps
= 16 };
232 virtual void setProperty(const char* propline
);
233 virtual const char* getProperty(const char* prop
);
236 /* JUnit-like assertions. Each returns TRUE if it succeeds. */
237 UBool
assertTrue(const char* message
, UBool condition
, UBool quiet
=FALSE
, UBool possibleDataError
=FALSE
, const char *file
=NULL
, int line
=0);
238 UBool
assertFalse(const char* message
, UBool condition
, UBool quiet
=FALSE
);
239 UBool
assertSuccess(const char* message
, UErrorCode ec
, UBool possibleDataError
=FALSE
);
240 UBool
assertEquals(const char* message
, const UnicodeString
& expected
,
241 const UnicodeString
& actual
, UBool possibleDataError
=FALSE
);
242 UBool
assertEquals(const char* message
, const char* expected
,
244 UBool
assertEquals(const char* message
, int32_t expected
, int32_t actual
);
245 #if !UCONFIG_NO_FORMATTING
246 UBool
assertEquals(const char* message
, const Formattable
& expected
,
247 const Formattable
& actual
);
248 UBool
assertEquals(const UnicodeString
& message
, const Formattable
& expected
,
249 const Formattable
& actual
);
251 UBool
assertTrue(const UnicodeString
& message
, UBool condition
, UBool quiet
=FALSE
);
252 UBool
assertFalse(const UnicodeString
& message
, UBool condition
, UBool quiet
=FALSE
);
253 UBool
assertSuccess(const UnicodeString
& message
, UErrorCode ec
);
254 UBool
assertEquals(const UnicodeString
& message
, const UnicodeString
& expected
,
255 const UnicodeString
& actual
);
256 UBool
assertEquals(const UnicodeString
& message
, const char* expected
,
259 virtual void runIndexedTest( int32_t index
, UBool exec
, const char* &name
, char* par
= NULL
); // overide !
261 virtual UBool
runTestLoop( char* testname
, char* par
, char *baseName
);
263 virtual int32_t IncErrorCount( void );
265 virtual int32_t IncDataErrorCount( void );
267 virtual UBool
callTest( IntlTest
& testToBeCalled
, char* par
);
274 UBool warn_on_missing_data
;
280 int32_t LL_indentlevel
;
283 int32_t dataErrorCount
;
285 char* testPath
; // specifies subtests
292 const char* proplines
[kMaxProps
];
297 virtual void LL_message( UnicodeString message
, UBool newline
);
299 // used for collation result reporting, defined here for convenience
301 static UnicodeString
&prettify(const UnicodeString
&source
, UnicodeString
&target
);
302 static UnicodeString
prettify(const UnicodeString
&source
, UBool parseBackslash
=FALSE
);
303 // digits=-1 determines the number of digits automatically
304 static UnicodeString
&appendHex(uint32_t number
, int32_t digits
, UnicodeString
&target
);
305 static UnicodeString
toHex(uint32_t number
, int32_t digits
=-1);
306 static inline UnicodeString
toHex(int32_t number
, int32_t digits
=-1) {
307 return toHex((uint32_t)number
, digits
);
311 static void setICU_DATA(); // Set up ICU_DATA if necessary.
313 static const char* pathToDataDirectory();
316 UBool
run_phase2( char* name
, char* par
); // internally, supports reporting memory leaks
317 static const char* loadTestData(UErrorCode
& err
);
318 virtual const char* getTestDataPath(UErrorCode
& err
);
319 static const char* getSourceTestData(UErrorCode
& err
);
323 static IntlTest
* gTest
;
324 static const char* fgDataDir
;
328 void it_log( UnicodeString message
);
329 void it_logln( UnicodeString message
);
330 void it_logln( void );
331 void it_info( UnicodeString message
);
332 void it_infoln( UnicodeString message
);
333 void it_infoln( void );
335 void it_err( UnicodeString message
);
336 void it_errln( UnicodeString message
);
337 void it_dataerr( UnicodeString message
);
338 void it_dataerrln( UnicodeString message
);
341 * This is a variant of cintltst/ccolltst.c:CharsToUChars().
342 * It converts a character string into a UnicodeString, with
343 * unescaping \u sequences.
345 extern UnicodeString
CharsToUnicodeString(const char* chars
);
347 /* alias for CharsToUnicodeString */
348 extern UnicodeString
ctou(const char* chars
);