410 lines
15 KiB
C++
410 lines
15 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1997-2016, 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"
|
|
|
|
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 DoubleToUnicodeString(double 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
|
|
UnicodeString toString(UBool b);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// 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_CLASS(TestClass) \
|
|
if (index == testCaseAutoNumber++) { \
|
|
name = #TestClass; \
|
|
if (exec) { \
|
|
logln(#TestClass "---"); \
|
|
logln(); \
|
|
TestClass test; \
|
|
callTest(test, par); \
|
|
} \
|
|
break; \
|
|
}
|
|
|
|
#define TESTCASE_AUTO_CREATE_CLASS(TestClass) \
|
|
if (index == testCaseAutoNumber++) { \
|
|
name = #TestClass; \
|
|
if (exec) { \
|
|
logln(#TestClass "---"); \
|
|
logln(); \
|
|
LocalPointer<IntlTest> test(create##TestClass()); \
|
|
callTest(*test, par); \
|
|
} \
|
|
break; \
|
|
}
|
|
|
|
#define TESTCASE_AUTO_END \
|
|
name = ""; \
|
|
break; \
|
|
}
|
|
|
|
#define TEST_ASSERT_TRUE(x) \
|
|
assertTrue(#x, (x), FALSE, FALSE, __FILE__, __LINE__)
|
|
|
|
#define TEST_ASSERT_STATUS(x) \
|
|
assertSuccess(#x, (x), 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 );
|
|
|
|
/**
|
|
* Replaces isICUVersionAtLeast and isICUVersionBefore
|
|
* log that an issue is known.
|
|
* Usually used this way:
|
|
* <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code>
|
|
* @param ticket ticket string, "12345" or "cldrbug:1234"
|
|
* @param message optional message string
|
|
* @return true if test should be skipped
|
|
*/
|
|
UBool logKnownIssue( const char *ticket, const UnicodeString &message );
|
|
/**
|
|
* Replaces isICUVersionAtLeast and isICUVersionBefore
|
|
* log that an issue is known.
|
|
* Usually used this way:
|
|
* <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code>
|
|
* @param ticket ticket string, "12345" or "cldrbug:1234"
|
|
* @return true if test should be skipped
|
|
*/
|
|
UBool logKnownIssue( const char *ticket );
|
|
/**
|
|
* Replaces isICUVersionAtLeast and isICUVersionBefore
|
|
* log that an issue is known.
|
|
* Usually used this way:
|
|
* <code>if( ... && logKnownIssue("12345", "some bug")) continue; </code>
|
|
* @param ticket ticket string, "12345" or "cldrbug:1234"
|
|
* @param message optional message string
|
|
* @return true if test should be skipped
|
|
*/
|
|
UBool logKnownIssue( const char *ticket, const char *fmt, ...);
|
|
|
|
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, ...);
|
|
|
|
/**
|
|
* logs an error (even if status==U_ZERO_ERROR), but
|
|
* calls dataerrln() or errln() depending on the type of error.
|
|
* Does not report the status code.
|
|
* @param status parameter for selecting whether errln or dataerrln is called.
|
|
*/
|
|
void errcheckln(UErrorCode status, const char *fmt, ...);
|
|
|
|
// Print ALL named errors encountered so far
|
|
void printErrors();
|
|
|
|
// print known issues. return TRUE if there were any.
|
|
UBool printKnownIssues();
|
|
|
|
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();
|
|
|
|
|
|
/**
|
|
* Integer random numbers, similar to C++ std::minstd_rand, with the same algorithm
|
|
* and constants. Allow additional access to internal state, for use by monkey tests,
|
|
* which need to recreate previous random sequences beginning near a failure point.
|
|
*/
|
|
class icu_rand {
|
|
public:
|
|
icu_rand(uint32_t seed = 1);
|
|
~icu_rand();
|
|
void seed(uint32_t seed);
|
|
uint32_t operator()();
|
|
/**
|
|
* Get a seed corresponding to the current state of the generator.
|
|
* Seeding any generator with this value will cause it to produce the
|
|
* same sequence as this one will from this point forward.
|
|
*/
|
|
uint32_t getSeed();
|
|
private:
|
|
uint32_t fLast;
|
|
};
|
|
|
|
|
|
|
|
enum { kMaxProps = 16 };
|
|
|
|
virtual void setProperty(const char* propline);
|
|
virtual const char* getProperty(const char* prop);
|
|
|
|
/* 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);
|
|
/**
|
|
* @param possibleDataError - if TRUE, use dataerrln instead of errcheckln on failure
|
|
* @return TRUE on success, FALSE on failure.
|
|
*/
|
|
UBool assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError=FALSE, const char *file=NULL, int line=0);
|
|
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, UBool expected,
|
|
UBool actual);
|
|
UBool assertEquals(const char* message, int32_t expected, int32_t actual);
|
|
UBool assertEquals(const char* message, int64_t expected, int64_t actual);
|
|
UBool assertEquals(const char* message, double expected, double actual);
|
|
#if !UCONFIG_NO_FORMATTING
|
|
UBool assertEquals(const char* message, const Formattable& expected,
|
|
const Formattable& actual, UBool possibleDataError=FALSE);
|
|
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 possibleDataError=FALSE);
|
|
UBool assertEquals(const UnicodeString& message, const char* expected,
|
|
const char* actual);
|
|
UBool assertEquals(const UnicodeString& message, UBool expected, UBool actual);
|
|
UBool assertEquals(const UnicodeString& message, int32_t expected, int32_t actual);
|
|
UBool assertEquals(const UnicodeString& message, int64_t expected, int64_t 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];
|
|
char currName[1024]; // current test name
|
|
|
|
//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 char *getUnidataPath(char path[]);
|
|
|
|
// 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
|