/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2003, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#ifndef _INTLTEST
#define _INTLTEST
-#include <stdio.h>
-
-#include "unicode/utypes.h"
-#include "unicode/unistr.h"
+// 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
-#ifdef OS390
+#if U_PLATFORM == U_PF_OS390
// avoid collision with math.h/log()
-// this must be after including utypes.h so that OS390 is actually defined
+// this must be after including utypes.h so that U_PLATFORM is actually defined
#pragma map(IntlTest::log( const UnicodeString &message ),"logos390")
#endif
-#define it_out (*IntlTest::gTest)
-
//-----------------------------------------------------------------------------
//convenience classes to ease porting code that uses the Java
//string-concatenation operator (moved from findword test by rtg)
UnicodeString UCharToUnicodeString(UChar c);
-UnicodeString operator+(const UnicodeString& left, const UnicodeString& right);
+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, 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
name = #test; \
if (exec) { \
logln(#test "---"); \
- logln((UnicodeString)""); \
+ logln(); \
test(); \
} \
break
-class IntlTest {
+// 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 ); // not to be overidden
+ 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 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 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 ) ;
- FILE *testoutfp;
+ /**
+ * 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();
+
+ 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);
+ /**
+ * @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);
+#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 );
+ 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 verbose;
+ UBool no_err_msg;
+ UBool quick;
+ UBool leaks;
+ UBool warn_on_missing_data;
+ UBool no_time;
+ int32_t threadCount;
private:
- UBool LL_linestart;
+ UBool LL_linestart;
int32_t LL_indentlevel;
int32_t errorCount;
+ int32_t dataErrorCount;
IntlTest* caller;
- char* path; // specifies subtests
+ 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);
-
- /* complete a relative path to a full pathname, and convert to platform-specific syntax. */
- /* The character seperating directories for the relative path is '|'. */
- static void pathnameInContext( char* fullname, int32_t maxsize, const char* relpath );
+ 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.
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:
void it_err(void);
void it_err( UnicodeString message );
void it_errln( UnicodeString message );
-
-IntlTest& operator<<(IntlTest& test, const UnicodeString& string);
-IntlTest& operator<<(IntlTest& test, const char* string);
-IntlTest& operator<<(IntlTest& test, const int32_t num);
-
-IntlTest& endl( IntlTest& test );
-IntlTest& operator<<(IntlTest& test, IntlTest& ( * _f)(IntlTest&));
+void it_dataerr( UnicodeString message );
+void it_dataerrln( UnicodeString message );
/**
* This is a variant of cintltst/ccolltst.c:CharsToUChars().
*/
extern UnicodeString CharsToUnicodeString(const char* chars);
+/* alias for CharsToUnicodeString */
+extern UnicodeString ctou(const char* chars);
+
#endif // _INTLTEST
projects / apple / icu.git / blobdiff