ICU-531.30.tar.gz

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

diff --git a/icuSources/test/intltest/intltest.h b/icuSources/test/intltest/intltest.h
index 940dbe54faf36aec420fe62561f2ee94b3643cf8..4e78ec5c117b6f26ad8427ca03af0a6cf4db3c18 100644 (file)
--- a/icuSources/test/intltest/intltest.h
+++ b/icuSources/test/intltest/intltest.h
@@ -1,6 +1,6 @@
 /********************************************************************
  * COPYRIGHT: 
 /********************************************************************
  * COPYRIGHT: 

- * Copyright (c) 1997-2003, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and

  * others. All Rights Reserved.
  ********************************************************************/
 
  * others. All Rights Reserved.
  ********************************************************************/
 


@@ -11,40 +11,63 @@
 #ifndef _INTLTEST
 #define _INTLTEST
 
 #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/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
 
 
 U_NAMESPACE_USE
 

-#ifdef OS390
+#if U_PLATFORM == U_PF_OS390

 // avoid collision with math.h/log()
 // 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
 
 #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);
 //-----------------------------------------------------------------------------
 //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, 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 operator+(const UnicodeString& left, float num);
 #if !UCONFIG_NO_FORMATTING
 UnicodeString toString(const Formattable& f); // liu

+UnicodeString toString(int32_t n);

 #endif
 #endif

+UnicodeString toString(UBool b);
+

 //-----------------------------------------------------------------------------
 
 // Use the TESTCASE macro in subclasses of IntlTest.  Define the
 //-----------------------------------------------------------------------------
 
 // Use the TESTCASE macro in subclasses of IntlTest.  Define the


@@ -64,24 +87,89 @@ UnicodeString toString(const Formattable& f); // liu
         name = #test;                 \
         if (exec) {                   \
             logln(#test "---");       \
         name = #test;                 \
         if (exec) {                   \
             logln(#test "---");       \

-            logln((UnicodeString)""); \
+            logln();                  \

             test();                   \
         }                             \
         break
 
             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();
 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 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 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 setCaller( IntlTest* callingTest ); // for internal use only
     virtual void setPath( char* path ); // for internal use only


@@ -92,6 +180,36 @@ public:
 
     virtual void logln( void );
 
 
     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 info( const UnicodeString &message );
 
     virtual void infoln( const UnicodeString &message );


@@ -99,11 +217,17 @@ public:
     virtual void infoln( void );
 
     virtual void err(void);
     virtual void infoln( void );
 
     virtual void err(void);

-    
+

     virtual void err( const UnicodeString &message );
 
     virtual void errln( const UnicodeString &message );
 
     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, ...);
     // convenience functions: sprintf() + errln() etc.
     void log(const char *fmt, ...);
     void logln(const char *fmt, ...);


@@ -111,49 +235,131 @@ public:
     void infoln(const char *fmt, ...);
     void err(const char *fmt, ...);
     void errln(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 ALL named errors encountered so far
     void printErrors(); 

+
+    // print known issues. return TRUE if there were any.
+    UBool printKnownIssues();

         
     virtual void usage( void ) ;
 
         
     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:
 
 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 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 IncErrorCount( void );
 

+    virtual int32_t IncDataErrorCount( void );
+

     virtual UBool callTest( IntlTest& testToBeCalled, char* par );
 
 
     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:
 
 private:

-    UBool      LL_linestart;
+    UBool       LL_linestart;

     int32_t     LL_indentlevel;
 
     int32_t     errorCount;
     int32_t     LL_indentlevel;
 
     int32_t     errorCount;

+    int32_t     dataErrorCount;

     IntlTest*   caller;
     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:
 
 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);
     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 &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:
     static void setICU_DATA();       // Set up ICU_DATA if necessary.


@@ -163,6 +369,8 @@ public:
 public:
     UBool run_phase2( char* name, char* par ); // internally, supports reporting memory leaks
     static const char* loadTestData(UErrorCode& err);
 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 members
 public:


@@ -180,13 +388,8 @@ void it_infoln( void );
 void it_err(void);
 void it_err( UnicodeString message );
 void it_errln( UnicodeString message );
 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().
 
 /**
  * This is a variant of cintltst/ccolltst.c:CharsToUChars().


@@ -195,4 +398,7 @@ IntlTest& operator<<(IntlTest& test,  IntlTest& ( * _f)(IntlTest&));
  */
 extern UnicodeString CharsToUnicodeString(const char* chars);
 
  */
 extern UnicodeString CharsToUnicodeString(const char* chars);
 

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

 #endif // _INTLTEST
 #endif // _INTLTEST