[apple/icu.git] / icuSources / test / intltest / intltest.h

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2013, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/


/**
 * IntlTest is a base class for tests.  */

#ifndef _INTLTEST
#define _INTLTEST

// The following includes utypes.h, uobject.h and unistr.h
#include "unicode/fmtable.h"
#include "unicode/testlog.h"


#if U_NO_DEFAULT_INCLUDE_UTF_HEADERS
/* deprecated  - make tests pass with U_NO_DEFAULT_INCLUDE_UTF_HEADERS */
#include "unicode/utf_old.h" 
#endif

/**
 * \def ICU_USE_THREADS
 *
 * Enables multi-threaded testing. Moved here from uconfig.h.
 * Default: enabled
 *
 * This switch used to allow thread support (use of mutexes) to be compiled out of ICU.
 */
#ifdef ICU_USE_THREADS
    /* Use the predefined value. */
#elif defined(APP_NO_THREADS)
    /* APP_NO_THREADS is an old symbol. We'll honour it if present. */
#   define ICU_USE_THREADS 0
#else
#   define ICU_USE_THREADS 1
#endif

U_NAMESPACE_USE

#if U_PLATFORM == U_PF_OS390
// avoid collision with math.h/log()
// this must be after including utypes.h so that U_PLATFORM is actually defined
#pragma map(IntlTest::log( const UnicodeString &message ),"logos390")
#endif

//-----------------------------------------------------------------------------
//convenience classes to ease porting code that uses the Java
//string-concatenation operator (moved from findword test by rtg)
UnicodeString UCharToUnicodeString(UChar c);
UnicodeString Int64ToUnicodeString(int64_t num);
//UnicodeString operator+(const UnicodeString& left, int64_t num); // Some compilers don't allow this because of the long type.
UnicodeString operator+(const UnicodeString& left, long num);
UnicodeString operator+(const UnicodeString& left, unsigned long num);
UnicodeString operator+(const UnicodeString& left, double num);
UnicodeString operator+(const UnicodeString& left, char num); 
UnicodeString operator+(const UnicodeString& left, short num);  
UnicodeString operator+(const UnicodeString& left, int num);      
UnicodeString operator+(const UnicodeString& left, unsigned char num);  
UnicodeString operator+(const UnicodeString& left, unsigned short num);  
UnicodeString operator+(const UnicodeString& left, unsigned int num);      
UnicodeString operator+(const UnicodeString& left, float num);
#if !UCONFIG_NO_FORMATTING
UnicodeString toString(const Formattable& f); // liu
UnicodeString toString(int32_t n);
#endif
//-----------------------------------------------------------------------------

// Use the TESTCASE macro in subclasses of IntlTest.  Define the
// runIndexedTest method in this fashion:
//
//| void MyTest::runIndexedTest(int32_t index, UBool exec,
//|                             const char* &name, char* /*par*/) {
//|     switch (index) {
//|         TESTCASE(0,TestSomething);
//|         TESTCASE(1,TestSomethingElse);
//|         TESTCASE(2,TestAnotherThing);
//|         default: name = ""; break;
//|     }
//| }
#define TESTCASE(id,test)             \
    case id:                          \
        name = #test;                 \
        if (exec) {                   \
            logln(#test "---");       \
            logln();                  \
            test();                   \
        }                             \
        break

// More convenient macros. These allow easy reordering of the test cases.
//
//| void MyTest::runIndexedTest(int32_t index, UBool exec,
//|                             const char* &name, char* /*par*/) {
//|     TESTCASE_AUTO_BEGIN;
//|     TESTCASE_AUTO(TestSomething);
//|     TESTCASE_AUTO(TestSomethingElse);
//|     TESTCASE_AUTO(TestAnotherThing);
//|     TESTCASE_AUTO_END;
//| }
#define TESTCASE_AUTO_BEGIN \
    for(;;) { \
        int32_t testCaseAutoNumber = 0

#define TESTCASE_AUTO(test) \
        if (index == testCaseAutoNumber++) { \
            name = #test; \
            if (exec) { \
                logln(#test "---"); \
                logln(); \
                test(); \
            } \
            break; \
        }

#define TESTCASE_AUTO_END \
        name = ""; \
        break; \
    }

#define TEST_ASSERT_TRUE(x) \
  assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__)

class IntlTest : public TestLog {
public:

    IntlTest();
    // TestLog has a virtual destructor.

    virtual UBool runTest( char* name = NULL, char* par = NULL, char *baseName = NULL); // not to be overidden

    virtual UBool setVerbose( UBool verbose = TRUE );
    virtual UBool setNoErrMsg( UBool no_err_msg = TRUE );
    virtual UBool setQuick( UBool quick = TRUE );
    virtual UBool setLeaks( UBool leaks = TRUE );
    virtual UBool setNotime( UBool no_time = TRUE );
    virtual UBool setWarnOnMissingData( UBool warn_on_missing_data = TRUE );
    virtual int32_t setThreadCount( int32_t count = 1);

    virtual int32_t getErrors( void );
    virtual int32_t getDataErrors (void );

    virtual void setCaller( IntlTest* callingTest ); // for internal use only
    virtual void setPath( char* path ); // for internal use only

    virtual void log( const UnicodeString &message );

    virtual void logln( const UnicodeString &message );

    virtual void logln( void );

    virtual void info( const UnicodeString &message );

    virtual void infoln( const UnicodeString &message );

    virtual void infoln( void );

    virtual void err(void);
    
    virtual void err( const UnicodeString &message );

    virtual void errln( const UnicodeString &message );

    virtual void dataerr( const UnicodeString &message );

    virtual void dataerrln( const UnicodeString &message );
    
    void errcheckln(UErrorCode status, const UnicodeString &message );

    // convenience functions: sprintf() + errln() etc.
    void log(const char *fmt, ...);
    void logln(const char *fmt, ...);
    void info(const char *fmt, ...);
    void infoln(const char *fmt, ...);
    void err(const char *fmt, ...);
    void errln(const char *fmt, ...);
    void dataerr(const char *fmt, ...);
    void dataerrln(const char *fmt, ...);
    void errcheckln(UErrorCode status, const char *fmt, ...);

    // Print ALL named errors encountered so far
    void printErrors(); 
        
    virtual void usage( void ) ;

    /**
     * Returns a uniform random value x, with 0.0 <= x < 1.0.  Use
     * with care: Does not return all possible values; returns one of
     * 714,025 values, uniformly spaced.  However, the period is
     * effectively infinite.  See: Numerical Recipes, section 7.1.
     *
     * @param seedp pointer to seed. Set *seedp to any negative value
     * to restart the sequence.
     */
    static float random(int32_t* seedp);

    /**
     * Convenience method using a global seed.
     */
    static float random();

    /**
     * Returns true if u_getVersion() < major.minor.
     */
    static UBool isICUVersionBefore(int major, int minor) {
        return isICUVersionBefore(major, minor, 0);
    }

    /**
     * Returns true if u_getVersion() < major.minor.milli.
     */
    static UBool isICUVersionBefore(int major, int minor, int milli);

    /**
     * Returns true if u_getVersion() >= major.minor.
     */
    static UBool isICUVersionAtLeast(int major, int minor) {
        return isICUVersionAtLeast(major, minor, 0);
    }

    /**
     * Returns true if u_getVersion() >= major.minor.milli.
     */
    static UBool isICUVersionAtLeast(int major, int minor, int milli) {
        return !isICUVersionBefore(major, minor, milli);
    }

    enum { kMaxProps = 16 };

    virtual void setProperty(const char* propline);
    virtual const char* getProperty(const char* prop);

protected:
    /* JUnit-like assertions. Each returns TRUE if it succeeds. */
    UBool assertTrue(const char* message, UBool condition, UBool quiet=FALSE, UBool possibleDataError=FALSE, const char *file=NULL, int line=0);
    UBool assertFalse(const char* message, UBool condition, UBool quiet=FALSE);
    UBool assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError=FALSE);
    UBool assertEquals(const char* message, const UnicodeString& expected,
                       const UnicodeString& actual, UBool possibleDataError=FALSE);
    UBool assertEquals(const char* message, const char* expected,
                       const char* actual);
    UBool assertEquals(const char* message, int32_t expected, int32_t actual);
#if !UCONFIG_NO_FORMATTING
    UBool assertEquals(const char* message, const Formattable& expected,
                       const Formattable& actual);
    UBool assertEquals(const UnicodeString& message, const Formattable& expected,
                       const Formattable& actual);
#endif
    UBool assertTrue(const UnicodeString& message, UBool condition, UBool quiet=FALSE);
    UBool assertFalse(const UnicodeString& message, UBool condition, UBool quiet=FALSE);
    UBool assertSuccess(const UnicodeString& message, UErrorCode ec);
    UBool assertEquals(const UnicodeString& message, const UnicodeString& expected,
                       const UnicodeString& actual);
    UBool assertEquals(const UnicodeString& message, const char* expected,
                       const char* actual);

    virtual void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL ); // overide !

    virtual UBool runTestLoop( char* testname, char* par, char *baseName );

    virtual int32_t IncErrorCount( void );

    virtual int32_t IncDataErrorCount( void );

    virtual UBool callTest( IntlTest& testToBeCalled, char* par );


    UBool       verbose;
    UBool       no_err_msg;
    UBool       quick;
    UBool       leaks;
    UBool       warn_on_missing_data;
    UBool       no_time;
    int32_t     threadCount;

private:
    UBool       LL_linestart;
    int32_t     LL_indentlevel;

    int32_t     errorCount;
    int32_t     dataErrorCount;
    IntlTest*   caller;
    char*       testPath;           // specifies subtests
    
    char basePath[1024];

    //FILE *testoutfp;
    void *testoutfp;

    const char* proplines[kMaxProps];
    int32_t     numProps;

protected:

    virtual void LL_message( UnicodeString message, UBool newline );

    // used for collation result reporting, defined here for convenience

    static UnicodeString &prettify(const UnicodeString &source, UnicodeString &target);
    static UnicodeString prettify(const UnicodeString &source, UBool parseBackslash=FALSE);
    // digits=-1 determines the number of digits automatically
    static UnicodeString &appendHex(uint32_t number, int32_t digits, UnicodeString &target);
    static UnicodeString toHex(uint32_t number, int32_t digits=-1);
    static inline UnicodeString toHex(int32_t number, int32_t digits=-1) {
        return toHex((uint32_t)number, digits);
    }

public:
    static void setICU_DATA();       // Set up ICU_DATA if necessary.

    static const char* pathToDataDirectory();

public:
    UBool run_phase2( char* name, char* par ); // internally, supports reporting memory leaks
    static const char* loadTestData(UErrorCode& err);
    virtual const char* getTestDataPath(UErrorCode& err);
    static const char* getSourceTestData(UErrorCode& err);

// static members
public:
    static IntlTest* gTest;
    static const char* fgDataDir;

};

void it_log( UnicodeString message );
void it_logln( UnicodeString message );
void it_logln( void );
void it_info( UnicodeString message );
void it_infoln( UnicodeString message );
void it_infoln( void );
void it_err(void);
void it_err( UnicodeString message );
void it_errln( UnicodeString message );
void it_dataerr( UnicodeString message );
void it_dataerrln( UnicodeString message );

/**
 * This is a variant of cintltst/ccolltst.c:CharsToUChars().
 * It converts a character string into a UnicodeString, with
 * unescaping \u sequences.
 */
extern UnicodeString CharsToUnicodeString(const char* chars);

/* alias for CharsToUnicodeString */
extern UnicodeString ctou(const char* chars);

#endif // _INTLTEST
Commit	Line	Data
b75a7d8f A	1	/********************************************************************
b75a7d8f A	2	* COPYRIGHT:
51004dcb	3	* Copyright (c) 1997-2013, International Business Machines Corporation and
b75a7d8f A	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
374ca955	14	// The following includes utypes.h, uobject.h and unistr.h
b75a7d8f	15	#include "unicode/fmtable.h"
374ca955	16	#include "unicode/testlog.h"
b75a7d8f	17
51004dcb A	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
b75a7d8f A	41	U_NAMESPACE_USE
b75a7d8f A	42
4388f060	43	#if U_PLATFORM == U_PF_OS390
b75a7d8f	44	// avoid collision with math.h/log()
4388f060	45	// this must be after including utypes.h so that U_PLATFORM is actually defined
b75a7d8f A	46	#pragma map(IntlTest::log( const UnicodeString &message ),"logos390")
	47	#endif
	48
b75a7d8f A	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);
374ca955 A	53	UnicodeString Int64ToUnicodeString(int64_t num);
374ca955 A	54	//UnicodeString operator+(const UnicodeString& left, int64_t num); // Some compilers don't allow this because of the long type.
b75a7d8f A	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
374ca955	67	UnicodeString toString(int32_t n);
b75a7d8f A	68	#endif
	69	//-----------------------------------------------------------------------------
	70
	71	// Use the TESTCASE macro in subclasses of IntlTest. Define the
	72	// runIndexedTest method in this fashion:
	73	//
	74	//\| void MyTest::runIndexedTest(int32_t index, UBool exec,
	75	//\| const char* &name, char* /par/) {
	76	//\| switch (index) {
	77	//\| TESTCASE(0,TestSomething);
	78	//\| TESTCASE(1,TestSomethingElse);
	79	//\| TESTCASE(2,TestAnotherThing);
	80	//\| default: name = ""; break;
	81	//\| }
	82	//\| }
	83	#define TESTCASE(id,test) \
	84	case id: \
	85	name = #test; \
	86	if (exec) { \
	87	logln(#test "---"); \
729e4ab9	88	logln(); \
b75a7d8f A	89	test(); \
	90	} \
	91	break
	92
729e4ab9 A	93	// More convenient macros. These allow easy reordering of the test cases.
	94	//
	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;
	102	//\| }
	103	#define TESTCASE_AUTO_BEGIN \
	104	for(;;) { \
	105	int32_t testCaseAutoNumber = 0
	106
	107	#define TESTCASE_AUTO(test) \
	108	if (index == testCaseAutoNumber++) { \
	109	name = #test; \
	110	if (exec) { \
	111	logln(#test "---"); \
	112	logln(); \
	113	test(); \
	114	} \
	115	break; \
	116	}
	117
	118	#define TESTCASE_AUTO_END \
	119	name = ""; \
	120	break; \
	121	}
	122
51004dcb A	123	#define TEST_ASSERT_TRUE(x) \
	124	assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__)
	125
374ca955	126	class IntlTest : public TestLog {
b75a7d8f A	127	public:
	128
	129	IntlTest();
729e4ab9	130	// TestLog has a virtual destructor.
b75a7d8f	131
729e4ab9	132	virtual UBool runTest( char* name = NULL, char* par = NULL, char *baseName = NULL); // not to be overidden
b75a7d8f A	133
	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 );
51004dcb	138	virtual UBool setNotime( UBool no_time = TRUE );
73c04bcf	139	virtual UBool setWarnOnMissingData( UBool warn_on_missing_data = TRUE );
729e4ab9	140	virtual int32_t setThreadCount( int32_t count = 1);
b75a7d8f A	141
b75a7d8f A	142	virtual int32_t getErrors( void );
73c04bcf	143	virtual int32_t getDataErrors (void );
b75a7d8f A	144
	145	virtual void setCaller( IntlTest* callingTest ); // for internal use only
	146	virtual void setPath( char* path ); // for internal use only
	147
	148	virtual void log( const UnicodeString &message );
	149
	150	virtual void logln( const UnicodeString &message );
	151
	152	virtual void logln( void );
	153
	154	virtual void info( const UnicodeString &message );
	155
	156	virtual void infoln( const UnicodeString &message );
	157
	158	virtual void infoln( void );
	159
	160	virtual void err(void);
	161
	162	virtual void err( const UnicodeString &message );
	163
	164	virtual void errln( const UnicodeString &message );
	165
73c04bcf A	166	virtual void dataerr( const UnicodeString &message );
	167
	168	virtual void dataerrln( const UnicodeString &message );
729e4ab9 A	169
729e4ab9 A	170	void errcheckln(UErrorCode status, const UnicodeString &message );
73c04bcf	171
b75a7d8f A	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, ...);
73c04bcf A	179	void dataerr(const char *fmt, ...);
73c04bcf A	180	void dataerrln(const char *fmt, ...);
729e4ab9	181	void errcheckln(UErrorCode status, const char *fmt, ...);
b75a7d8f A	182
	183	// Print ALL named errors encountered so far
	184	void printErrors();
	185
	186	virtual void usage( void ) ;
	187
374ca955 A	188	/**
	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.
	193	*
	194	* @param seedp pointer to seed. Set *seedp to any negative value
	195	* to restart the sequence.
	196	*/
	197	static float random(int32_t* seedp);
	198
	199	/**
	200	* Convenience method using a global seed.
	201	*/
	202	static float random();
	203
	204	/**
4388f060	205	* Returns true if u_getVersion() < major.minor.
374ca955	206	*/
4388f060 A	207	static UBool isICUVersionBefore(int major, int minor) {
	208	return isICUVersionBefore(major, minor, 0);
	209	}
	210
	211	/**
	212	* Returns true if u_getVersion() < major.minor.milli.
	213	*/
	214	static UBool isICUVersionBefore(int major, int minor, int milli);
	215
	216	/**
	217	* Returns true if u_getVersion() >= major.minor.
	218	*/
	219	static UBool isICUVersionAtLeast(int major, int minor) {
	220	return isICUVersionAtLeast(major, minor, 0);
	221	}
	222
	223	/**
	224	* Returns true if u_getVersion() >= major.minor.milli.
	225	*/
	226	static UBool isICUVersionAtLeast(int major, int minor, int milli) {
	227	return !isICUVersionBefore(major, minor, milli);
	228	}
b75a7d8f	229
729e4ab9 A	230	enum { kMaxProps = 16 };
	231
	232	virtual void setProperty(const char* propline);
	233	virtual const char* getProperty(const char* prop);
	234
b75a7d8f	235	protected:
374ca955	236	/* JUnit-like assertions. Each returns TRUE if it succeeds. */
51004dcb	237	UBool assertTrue(const char* message, UBool condition, UBool quiet=FALSE, UBool possibleDataError=FALSE, const char *file=NULL, int line=0);
374ca955	238	UBool assertFalse(const char* message, UBool condition, UBool quiet=FALSE);
729e4ab9	239	UBool assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError=FALSE);
374ca955	240	UBool assertEquals(const char* message, const UnicodeString& expected,
729e4ab9	241	const UnicodeString& actual, UBool possibleDataError=FALSE);
374ca955 A	242	UBool assertEquals(const char* message, const char* expected,
374ca955 A	243	const char* actual);
51004dcb	244	UBool assertEquals(const char* message, int32_t expected, int32_t actual);
374ca955 A	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);
	250	#endif
	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,
	257	const char* actual);
	258
b75a7d8f A	259	virtual void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL ); // overide !
b75a7d8f A	260
729e4ab9	261	virtual UBool runTestLoop( char* testname, char* par, char *baseName );
b75a7d8f A	262
	263	virtual int32_t IncErrorCount( void );
	264
73c04bcf A	265	virtual int32_t IncDataErrorCount( void );
73c04bcf A	266
b75a7d8f A	267	virtual UBool callTest( IntlTest& testToBeCalled, char* par );
	268
	269
73c04bcf A	270	UBool verbose;
	271	UBool no_err_msg;
	272	UBool quick;
	273	UBool leaks;
	274	UBool warn_on_missing_data;
51004dcb	275	UBool no_time;
729e4ab9	276	int32_t threadCount;
b75a7d8f A	277
b75a7d8f A	278	private:
73c04bcf	279	UBool LL_linestart;
b75a7d8f A	280	int32_t LL_indentlevel;
	281
	282	int32_t errorCount;
73c04bcf	283	int32_t dataErrorCount;
b75a7d8f	284	IntlTest* caller;
73c04bcf	285	char* testPath; // specifies subtests
729e4ab9 A	286
729e4ab9 A	287	char basePath[1024];
b75a7d8f	288
374ca955 A	289	//FILE *testoutfp;
	290	void *testoutfp;
	291
729e4ab9 A	292	const char* proplines[kMaxProps];
	293	int32_t numProps;
	294
b75a7d8f	295	protected:
374ca955	296
b75a7d8f A	297	virtual void LL_message( UnicodeString message, UBool newline );
	298
	299	// used for collation result reporting, defined here for convenience
	300
	301	static UnicodeString &prettify(const UnicodeString &source, UnicodeString &target);
	302	static UnicodeString prettify(const UnicodeString &source, UBool parseBackslash=FALSE);
51004dcb	303	// digits=-1 determines the number of digits automatically
b75a7d8f	304	static UnicodeString &appendHex(uint32_t number, int32_t digits, UnicodeString &target);
51004dcb A	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);
	308	}
b75a7d8f	309
b75a7d8f A	310	public:
	311	static void setICU_DATA(); // Set up ICU_DATA if necessary.
	312
	313	static const char* pathToDataDirectory();
	314
	315	public:
	316	UBool run_phase2( char* name, char* par ); // internally, supports reporting memory leaks
	317	static const char* loadTestData(UErrorCode& err);
374ca955 A	318	virtual const char* getTestDataPath(UErrorCode& err);
374ca955 A	319	static const char* getSourceTestData(UErrorCode& err);
b75a7d8f A	320
	321	// static members
	322	public:
	323	static IntlTest* gTest;
	324	static const char* fgDataDir;
	325
	326	};
	327
	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 );
	334	void it_err(void);
	335	void it_err( UnicodeString message );
	336	void it_errln( UnicodeString message );
73c04bcf A	337	void it_dataerr( UnicodeString message );
73c04bcf A	338	void it_dataerrln( UnicodeString message );
b75a7d8f	339
b75a7d8f A	340	/**
	341	* This is a variant of cintltst/ccolltst.c:CharsToUChars().
	342	* It converts a character string into a UnicodeString, with
	343	* unescaping \u sequences.
	344	*/
	345	extern UnicodeString CharsToUnicodeString(const char* chars);
	346
374ca955 A	347	/* alias for CharsToUnicodeString */
	348	extern UnicodeString ctou(const char* chars);
	349
b75a7d8f	350	#endif // _INTLTEST