1 /********************************************************************
2  * COPYRIGHT:
3  * Copyright (c) 1997-2014, 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 /**
25  * \def ICU_USE_THREADS
26  *
27  * Enables multi-threaded testing. Moved here from uconfig.h.
28  * Default: enabled
29  *
30  * This switch used to allow thread support (use of mutexes) to be compiled out of ICU.
31  */
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
37 #else
38 #   define ICU_USE_THREADS 1
39 #endif
40 
41 U_NAMESPACE_USE
42 
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")
47 #endif
48 
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);
68 #endif
69 UnicodeString toString(UBool b);
70 
71 //-----------------------------------------------------------------------------
72 
73 // Use the TESTCASE macro in subclasses of IntlTest.  Define the
74 // runIndexedTest method in this fashion:
75 //
76 //| void MyTest::runIndexedTest(int32_t index, UBool exec,
77 //|                             const char* &name, char* /*par*/) {
78 //|     switch (index) {
79 //|         TESTCASE(0,TestSomething);
80 //|         TESTCASE(1,TestSomethingElse);
81 //|         TESTCASE(2,TestAnotherThing);
82 //|         default: name = ""; break;
83 //|     }
84 //| }
85 #define TESTCASE(id,test)             \
86     case id:                          \
87         name = #test;                 \
88         if (exec) {                   \
89             logln(#test "---");       \
90             logln();                  \
91             test();                   \
92         }                             \
93         break
94 
95 // More convenient macros. These allow easy reordering of the test cases.
96 //
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;
104 //| }
105 #define TESTCASE_AUTO_BEGIN \
106     for(;;) { \
107         int32_t testCaseAutoNumber = 0
108 
109 #define TESTCASE_AUTO(test) \
110         if (index == testCaseAutoNumber++) { \
111             name = #test; \
112             if (exec) { \
113                 logln(#test "---"); \
114                 logln(); \
115                 test(); \
116             } \
117             break; \
118         }
119 
120 #define TESTCASE_AUTO_CLASS(TestClass) \
121         if (index == testCaseAutoNumber++) { \
122             name = #TestClass; \
123             if (exec) { \
124                 logln(#TestClass "---"); \
125                 logln(); \
126                 TestClass test; \
127                 callTest(test, par); \
128             } \
129             break; \
130         }
131 
132 #define TESTCASE_AUTO_CREATE_CLASS(TestClass) \
133         if (index == testCaseAutoNumber++) { \
134             name = #TestClass; \
135             if (exec) { \
136                 logln(#TestClass "---"); \
137                 logln(); \
138                 LocalPointer<IntlTest> test(create##TestClass()); \
139                 callTest(*test, par); \
140             } \
141             break; \
142         }
143 
144 #define TESTCASE_AUTO_END \
145         name = ""; \
146         break; \
147     }
148 
149 #define TEST_ASSERT_TRUE(x) \
150   assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__)
151 
152 #define TEST_ASSERT_STATUS(x) \
153   assertSuccess(#x, (x), FALSE, __FILE__, __LINE__)
154 
155 class IntlTest : public TestLog {
156 public:
157 
158     IntlTest();
159     // TestLog has a virtual destructor.
160 
161     virtual UBool runTest( char* name = NULL, char* par = NULL, char *baseName = NULL); // not to be overidden
162 
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);
170 
171     virtual int32_t getErrors( void );
172     virtual int32_t getDataErrors (void );
173 
174     virtual void setCaller( IntlTest* callingTest ); // for internal use only
175     virtual void setPath( char* path ); // for internal use only
176 
177     virtual void log( const UnicodeString &message );
178 
179     virtual void logln( const UnicodeString &message );
180 
181     virtual void logln( void );
182 
183     /**
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
191      */
192     UBool logKnownIssue( const char *ticket, const UnicodeString &message );
193     /**
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
200      */
201     UBool logKnownIssue( const char *ticket );
202     /**
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
210      */
211     UBool logKnownIssue( const char *ticket, const char *fmt, ...);
212 
213     virtual void info( const UnicodeString &message );
214 
215     virtual void infoln( const UnicodeString &message );
216 
217     virtual void infoln( void );
218 
219     virtual void err(void);
220 
221     virtual void err( const UnicodeString &message );
222 
223     virtual void errln( const UnicodeString &message );
224 
225     virtual void dataerr( const UnicodeString &message );
226 
227     virtual void dataerrln( const UnicodeString &message );
228 
229     void errcheckln(UErrorCode status, const UnicodeString &message );
230 
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, ...);
240 
241     /**
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.
246      */
247     void errcheckln(UErrorCode status, const char *fmt, ...);
248 
249     // Print ALL named errors encountered so far
250     void printErrors();
251 
252     // print known issues. return TRUE if there were any.
253     UBool printKnownIssues();
254 
255     virtual void usage( void ) ;
256 
257     /**
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.
262      *
263      * @param seedp pointer to seed. Set *seedp to any negative value
264      * to restart the sequence.
265      */
266     static float random(int32_t* seedp);
267 
268     /**
269      * Convenience method using a global seed.
270      */
271     static float random();
272 
273     enum { kMaxProps = 16 };
274 
275     virtual void setProperty(const char* propline);
276     virtual const char* getProperty(const char* prop);
277 
278 protected:
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);
282     /**
283      * @param possibleDataError - if TRUE, use dataerrln instead of errcheckln on failure
284      * @return TRUE on success, FALSE on failure.
285      */
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,
290                        const char* actual);
291     UBool assertEquals(const char* message, UBool expected,
292                        UBool actual);
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);
300 #endif
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,
307                        const char* actual);
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);
311 
312     virtual void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL ); // overide !
313 
314     virtual UBool runTestLoop( char* testname, char* par, char *baseName );
315 
316     virtual int32_t IncErrorCount( void );
317 
318     virtual int32_t IncDataErrorCount( void );
319 
320     virtual UBool callTest( IntlTest& testToBeCalled, char* par );
321 
322 
323     UBool       verbose;
324     UBool       no_err_msg;
325     UBool       quick;
326     UBool       leaks;
327     UBool       warn_on_missing_data;
328     UBool       no_time;
329     int32_t     threadCount;
330 
331 private:
332     UBool       LL_linestart;
333     int32_t     LL_indentlevel;
334 
335     int32_t     errorCount;
336     int32_t     dataErrorCount;
337     IntlTest*   caller;
338     char*       testPath;           // specifies subtests
339 
340     char basePath[1024];
341     char currName[1024]; // current test name
342 
343     //FILE *testoutfp;
344     void *testoutfp;
345 
346     const char* proplines[kMaxProps];
347     int32_t     numProps;
348 
349 protected:
350 
351     virtual void LL_message( UnicodeString message, UBool newline );
352 
353     // used for collation result reporting, defined here for convenience
354 
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);
362     }
363 
364 public:
365     static void setICU_DATA();       // Set up ICU_DATA if necessary.
366 
367     static const char* pathToDataDirectory();
368 
369 public:
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);
374     static char *getUnidataPath(char path[]);
375 
376 // static members
377 public:
378     static IntlTest* gTest;
379     static const char* fgDataDir;
380 
381 };
382 
383 void it_log( UnicodeString message );
384 void it_logln( UnicodeString message );
385 void it_logln( void );
386 void it_info( UnicodeString message );
387 void it_infoln( UnicodeString message );
388 void it_infoln( void );
389 void it_err(void);
390 void it_err( UnicodeString message );
391 void it_errln( UnicodeString message );
392 void it_dataerr( UnicodeString message );
393 void it_dataerrln( UnicodeString message );
394 
395 /**
396  * This is a variant of cintltst/ccolltst.c:CharsToUChars().
397  * It converts a character string into a UnicodeString, with
398  * unescaping \u sequences.
399  */
400 extern UnicodeString CharsToUnicodeString(const char* chars);
401 
402 /* alias for CharsToUnicodeString */
403 extern UnicodeString ctou(const char* chars);
404 
405 #endif // _INTLTEST
406