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
24U_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)
35UnicodeString UCharToUnicodeString(UChar c);
36UnicodeString Int64ToUnicodeString(int64_t num);
37//UnicodeString operator+(const UnicodeString& left, int64_t num); // Some compilers don't allow this because of the long type.
38UnicodeString operator+(const UnicodeString& left, long num);
39UnicodeString operator+(const UnicodeString& left, unsigned long num);
40UnicodeString operator+(const UnicodeString& left, double num);
41UnicodeString operator+(const UnicodeString& left, char num);
42UnicodeString operator+(const UnicodeString& left, short num);
43UnicodeString operator+(const UnicodeString& left, int num);
44UnicodeString operator+(const UnicodeString& left, unsigned char num);
45UnicodeString operator+(const UnicodeString& left, unsigned short num);
46UnicodeString operator+(const UnicodeString& left, unsigned int num);
47UnicodeString operator+(const UnicodeString& left, float num);
48#if !UCONFIG_NO_FORMATTING
49UnicodeString toString(const Formattable& f); // liu
50UnicodeString toString(int32_t n);
51#endif
52UnicodeString 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
138class IntlTest : public TestLog {
139public:
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
261protected:
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
315private:
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
333protected:
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
348public:
349    static void setICU_DATA();       // Set up ICU_DATA if necessary.
350
351    static const char* pathToDataDirectory();
352
353public:
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
361public:
362    static IntlTest* gTest;
363    static const char* fgDataDir;
364
365};
366
367void it_log( UnicodeString message );
368void it_logln( UnicodeString message );
369void it_logln( void );
370void it_info( UnicodeString message );
371void it_infoln( UnicodeString message );
372void it_infoln( void );
373void it_err(void);
374void it_err( UnicodeString message );
375void it_errln( UnicodeString message );
376void it_dataerr( UnicodeString message );
377void 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 */
384extern UnicodeString CharsToUnicodeString(const char* chars);
385
386/* alias for CharsToUnicodeString */
387extern UnicodeString ctou(const char* chars);
388
389#endif // _INTLTEST
390