ICU-511.34.tar.gz

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

diff --git a/icuSources/test/intltest/intltest.cpp b/icuSources/test/intltest/intltest.cpp
index 3f440b8f9de8cf07cc453b831fffeaab91169d5a..6d08af153d822bae757e85211bbe2fccf7e62df9 100644 (file)
--- a/icuSources/test/intltest/intltest.cpp
+++ b/icuSources/test/intltest/intltest.cpp
@@ -1,6 +1,6 @@
 /********************************************************************
  * COPYRIGHT:
 /********************************************************************
  * COPYRIGHT:

- * Copyright (c) 1997-2006, International Business Machines Corporation and
+ * Copyright (c) 1997-2013, International Business Machines Corporation and

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


@@ -35,9 +35,9 @@
 #include "cmemory.h"
 #include "uoptions.h"
 
 #include "cmemory.h"
 #include "uoptions.h"
 

-#include "putilimp.h" // for uprv_getUTCtime()
+#include "putilimp.h" // for uprv_getRawUTCtime()

 #include "unicode/locid.h"
 #include "unicode/locid.h"

-
+#include "unicode/ctest.h" // for str_timeDelta

 
 #ifdef XP_MAC_CONSOLE
 #include <console.h>
 
 #ifdef XP_MAC_CONSOLE
 #include <console.h>


@@ -92,7 +92,7 @@ Int64ToUnicodeString(int64_t num)
     char buffer[64];    // nos changed from 10 to 64
     char danger = 'p';  // guard against overrunning the buffer (rtg)
 
     char buffer[64];    // nos changed from 10 to 64
     char danger = 'p';  // guard against overrunning the buffer (rtg)
 

-#ifdef U_WINDOWS
+#if defined(_MSC_VER)

     sprintf(buffer, "%I64d", num);
 #else
     sprintf(buffer, "%lld", (long long)num);
     sprintf(buffer, "%I64d", num);
 #else
     sprintf(buffer, "%lld", (long long)num);


@@ -114,7 +114,7 @@ operator+(const UnicodeString& left,
     //  53*log(2)/log(10) = 15.95
     // so there is no need to show more than 16 digits. [alan]
 
     //  53*log(2)/log(10) = 15.95
     // so there is no need to show more than 16 digits. [alan]
 

-    sprintf(buffer, "%.16g", num);
+    sprintf(buffer, "%.17g", num);

     assert(danger == 'p');
 
     return left + buffer;
     assert(danger == 'p');
 
     return left + buffer;


@@ -123,7 +123,7 @@ operator+(const UnicodeString& left,
 #if !UCONFIG_NO_FORMATTING
 
 /**
 #if !UCONFIG_NO_FORMATTING
 
 /**

- * Return a string display for for this, without surrounding braces.
+ * Return a string display for this, without surrounding braces.

  */
 UnicodeString _toString(const Formattable& f) {
     UnicodeString s;
  */
 UnicodeString _toString(const Formattable& f) {
     UnicodeString s;


@@ -170,15 +170,15 @@ UnicodeString _toString(const Formattable& f) {
             }
         }
         break;
             }
         }
         break;

-    case Formattable::kObject:
-        if (f.getObject()->getDynamicClassID() ==
-            CurrencyAmount::getStaticClassID()) {
-            const CurrencyAmount& c = (const CurrencyAmount&) *f.getObject();
-            s = _toString(c.getNumber()) + " " + UnicodeString(c.getISOCurrency());
+    case Formattable::kObject: {
+        const CurrencyAmount* c = dynamic_cast<const CurrencyAmount*>(f.getObject());
+        if (c != NULL) {
+            s = _toString(c->getNumber()) + " " + UnicodeString(c->getISOCurrency());

         } else {
             s = UnicodeString("Unknown UObject");
         }
         break;
         } else {
             s = UnicodeString("Unknown UObject");
         }
         break;

+    }

     default:
         s = UnicodeString("Unknown Formattable type=") + (int32_t)f.getType();
         break;
     default:
         s = UnicodeString("Unknown Formattable type=") + (int32_t)f.getType();
         break;


@@ -233,6 +233,14 @@ IntlTest::appendHex(uint32_t number,
         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0
     }; /* "0123456789ABCDEF" */
 
         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0
     }; /* "0123456789ABCDEF" */
 

+    if (digits < 0) {  // auto-digits
+        digits = 2;
+        uint32_t max = 0xff;
+        while (number > max) {
+            digits += 2;
+            max = (max << 8) | 0xff;
+        }
+    }

     switch (digits)
     {
     case 8:
     switch (digits)
     {
     case 8:


@@ -258,6 +266,17 @@ IntlTest::appendHex(uint32_t number,
     return target;
 }
 
     return target;
 }
 

+UnicodeString
+IntlTest::toHex(uint32_t number, int32_t digits) {
+    UnicodeString result;
+    appendHex(number, digits, result);
+    return result;
+}
+
+static inline UBool isPrintable(UChar32 c) {
+    return c <= 0x7E && (c >= 0x20 || c == 9 || c == 0xA || c == 0xD);
+}
+

 // Replace nonprintable characters with unicode escapes
 UnicodeString&
 IntlTest::prettify(const UnicodeString &source,
 // Replace nonprintable characters with unicode escapes
 UnicodeString&
 IntlTest::prettify(const UnicodeString &source,


@@ -271,9 +290,9 @@ IntlTest::prettify(const UnicodeString &source,
     for (i = 0; i < source.length(); )
     {
         UChar32 ch = source.char32At(i);
     for (i = 0; i < source.length(); )
     {
         UChar32 ch = source.char32At(i);

-        i += UTF_CHAR_LENGTH(ch);
+        i += U16_LENGTH(ch);

 
 

-        if (ch < 0x09 || (ch > 0x0A && ch < 0x20)|| ch > 0x7E)
+        if (!isPrintable(ch))

         {
             if (ch <= 0xFFFF) {
                 target += "\\u";
         {
             if (ch <= 0xFFFF) {
                 target += "\\u";


@@ -306,9 +325,9 @@ IntlTest::prettify(const UnicodeString &source, UBool parseBackslash)
     for (i = 0; i < source.length();)
     {
         UChar32 ch = source.char32At(i);
     for (i = 0; i < source.length();)
     {
         UChar32 ch = source.char32At(i);

-        i += UTF_CHAR_LENGTH(ch);
+        i += U16_LENGTH(ch);

 
 

-        if (ch < 0x09 || (ch > 0x0A && ch < 0x20)|| ch > 0x7E)
+        if (!isPrintable(ch))

         {
             if (parseBackslash) {
                 // If we are preceded by an odd number of backslashes,
         {
             if (parseBackslash) {
                 // If we are preceded by an odd number of backslashes,


@@ -504,23 +523,32 @@ IntlTest::IntlTest()
     errorCount = 0;
     dataErrorCount = 0;
     verbose = FALSE;
     errorCount = 0;
     dataErrorCount = 0;
     verbose = FALSE;

+    no_time = FALSE;

     no_err_msg = FALSE;
     warn_on_missing_data = FALSE;
     quick = FALSE;
     leaks = FALSE;
     no_err_msg = FALSE;
     warn_on_missing_data = FALSE;
     quick = FALSE;
     leaks = FALSE;

+    threadCount = 1;

     testoutfp = stdout;
     LL_indentlevel = indentLevel_offset;
     testoutfp = stdout;
     LL_indentlevel = indentLevel_offset;

+    numProps = 0;
+    strcpy(basePath, "/");

 }
 
 void IntlTest::setCaller( IntlTest* callingTest )
 {
     caller = callingTest;
     if (caller) {
 }
 
 void IntlTest::setCaller( IntlTest* callingTest )
 {
     caller = callingTest;
     if (caller) {

+        warn_on_missing_data = caller->warn_on_missing_data;

         verbose = caller->verbose;
         no_err_msg = caller->no_err_msg;
         quick = caller->quick;
         testoutfp = caller->testoutfp;
         LL_indentlevel = caller->LL_indentlevel + indentLevel_offset;
         verbose = caller->verbose;
         no_err_msg = caller->no_err_msg;
         quick = caller->quick;
         testoutfp = caller->testoutfp;
         LL_indentlevel = caller->LL_indentlevel + indentLevel_offset;

+        numProps = caller->numProps;
+        for (int32_t i = 0; i < numProps; i++) {
+            proplines[i] = caller->proplines[i];
+        }

     }
 }
 
     }
 }
 


@@ -528,7 +556,10 @@ UBool IntlTest::callTest( IntlTest& testToBeCalled, char* par )
 {
     execCount--; // correct a previously assumed test-exec, as this only calls a subtest
     testToBeCalled.setCaller( this );
 {
     execCount--; // correct a previously assumed test-exec, as this only calls a subtest
     testToBeCalled.setCaller( this );

-    return testToBeCalled.runTest( testPath, par );
+    strcpy(testToBeCalled.basePath, this->basePath );
+    UBool result = testToBeCalled.runTest( testPath, par, testToBeCalled.basePath );
+    strcpy(testToBeCalled.basePath, this->basePath ); // reset it.
+    return result;

 }
 
 void IntlTest::setPath( char* pathVal )
 }
 
 void IntlTest::setPath( char* pathVal )


@@ -543,6 +574,13 @@ UBool IntlTest::setVerbose( UBool verboseVal )
     return rval;
 }
 
     return rval;
 }
 

+UBool IntlTest::setNotime( UBool no_time )
+{
+    UBool rval = this->no_time;
+    this->no_time = no_time;
+    return rval;
+}
+

 UBool IntlTest::setWarnOnMissingData( UBool warn_on_missing_dataVal )
 {
     UBool rval = this->warn_on_missing_data;
 UBool IntlTest::setWarnOnMissingData( UBool warn_on_missing_dataVal )
 {
     UBool rval = this->warn_on_missing_data;


@@ -571,6 +609,13 @@ UBool IntlTest::setLeaks( UBool leaksVal )
     return rval;
 }
 
     return rval;
 }
 

+int32_t IntlTest::setThreadCount( int32_t count )
+{
+    int32_t rval = this->threadCount;
+    this->threadCount = count;
+    return rval;
+}
+

 int32_t IntlTest::getErrors( void )
 {
     return errorCount;
 int32_t IntlTest::getErrors( void )
 {
     return errorCount;


@@ -581,11 +626,19 @@ int32_t IntlTest::getDataErrors( void )
     return dataErrorCount;
 }
 
     return dataErrorCount;
 }
 

-UBool IntlTest::runTest( char* name, char* par )
+UBool IntlTest::runTest( char* name, char* par, char *baseName )

 {
     UBool rval;
     char* pos = NULL;
 
 {
     UBool rval;
     char* pos = NULL;
 

+    char* baseNameBuffer = NULL;
+
+    if(baseName == NULL) {
+      baseNameBuffer = (char*)malloc(1024);
+      baseName=baseNameBuffer;
+      strcpy(baseName, "/");
+    }
+

     if (name)
         pos = strchr( name, delim ); // check if name contains path (by looking for '/')
     if (pos) {
     if (name)
         pos = strchr( name, delim ); // check if name contains path (by looking for '/')
     if (pos) {


@@ -596,23 +649,26 @@ UBool IntlTest::runTest( char* name, char* par )
     }
 
     if (!name || (name[0] == 0) || (strcmp(name, "*") == 0)) {
     }
 
     if (!name || (name[0] == 0) || (strcmp(name, "*") == 0)) {

-        rval = runTestLoop( NULL, par );
+      rval = runTestLoop( NULL, par, baseName );

 
     }else if (strcmp( name, "LIST" ) == 0) {
         this->usage();
         rval = TRUE;
 
     }else{
 
     }else if (strcmp( name, "LIST" ) == 0) {
         this->usage();
         rval = TRUE;
 
     }else{

-        rval = runTestLoop( name, par );
+      rval = runTestLoop( name, par, baseName );

     }
 
     if (pos)
         *pos = delim;  // restore original value at pos
     }
 
     if (pos)
         *pos = delim;  // restore original value at pos

+    if(baseNameBuffer!=NULL) {
+      free(baseNameBuffer);
+    }

     return rval;
 }
 
 // call individual tests, to be overriden to call implementations
     return rval;
 }
 
 // call individual tests, to be overriden to call implementations

-void IntlTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
+void IntlTest::runIndexedTest( int32_t /*index*/, UBool /*exec*/, const char* & /*name*/, char* /*par*/ )

 {
     // to be overriden by a method like:
     /*
 {
     // to be overriden by a method like:
     /*


@@ -623,11 +679,10 @@ void IntlTest::runIndexedTest( int32_t index, UBool exec, const char* &name, cha
     }
     */
     this->errln("*** runIndexedTest needs to be overriden! ***");
     }
     */
     this->errln("*** runIndexedTest needs to be overriden! ***");

-    name = ""; exec = exec; index = index; par = par;

 }
 
 
 }
 
 

-UBool IntlTest::runTestLoop( char* testname, char* par )
+UBool IntlTest::runTestLoop( char* testname, char* par, char *baseName )

 {
     int32_t    index = 0;
     const char*   name;
 {
     int32_t    index = 0;
     const char*   name;


@@ -636,28 +691,69 @@ UBool IntlTest::runTestLoop( char* testname, char* par )
     UBool  rval = FALSE;
     UBool   lastTestFailed;
 
     UBool  rval = FALSE;
     UBool   lastTestFailed;
 

+    if(baseName == NULL) {
+      printf("ERROR: baseName can't be null.\n");
+      return FALSE;
+    } else {
+      if ((char *)this->basePath != baseName) {
+        strcpy(this->basePath, baseName);
+      }
+    }
+
+    char * saveBaseLoc = baseName+strlen(baseName);
+

     IntlTest* saveTest = gTest;
     gTest = this;
     do {
         this->runIndexedTest( index, FALSE, name, par );
     IntlTest* saveTest = gTest;
     gTest = this;
     do {
         this->runIndexedTest( index, FALSE, name, par );

-        if (!name || (name[0] == 0))
-            break;
-        if (!testname) {
-            run_this_test = TRUE;
-        }else{
-            run_this_test = (UBool) (strcmp( name, testname ) == 0);
+        if (strcmp(name,"skip") == 0) {
+            run_this_test = FALSE;
+        } else {
+            if (!name || (name[0] == 0))
+                break;
+            if (!testname) {
+                run_this_test = TRUE;
+            }else{
+                run_this_test = (UBool) (strcmp( name, testname ) == 0);
+            }

         }
         if (run_this_test) {
             lastErrorCount = errorCount;
             execCount++;
         }
         if (run_this_test) {
             lastErrorCount = errorCount;
             execCount++;

+            char msg[256];
+            sprintf(msg, "%s {", name);
+            LL_message(msg, TRUE);
+            UDate timeStart = uprv_getRawUTCtime();
+            strcpy(saveBaseLoc,name);
+            strcat(saveBaseLoc,"/");
+

             this->runIndexedTest( index, TRUE, name, par );
             this->runIndexedTest( index, TRUE, name, par );

+
+            UDate timeStop = uprv_getRawUTCtime();

             rval = TRUE; // at least one test has been called
             rval = TRUE; // at least one test has been called

-            char msg[256];
+            char secs[256];
+            if(!no_time) {
+              sprintf(secs, "%f", (timeStop-timeStart)/1000.0);
+            } else {
+              secs[0]=0;
+            }
+            
+
+            strcpy(saveBaseLoc,name);
+
+
+            ctest_xml_testcase(baseName, name, secs, (lastErrorCount!=errorCount)?"err":NULL);
+            
+
+            saveBaseLoc[0]=0; /* reset path */
+            

             if (lastErrorCount == errorCount) {
             if (lastErrorCount == errorCount) {

-                sprintf( msg, "---OK:   %s", name );
+                sprintf( msg, "   } OK:   %s ", name );
+                if(!no_time) str_timeDelta(msg+strlen(msg),timeStop-timeStart);

                 lastTestFailed = FALSE;
             }else{
                 lastTestFailed = FALSE;
             }else{

-                sprintf(msg, "---ERRORS (%li) in %s", (long)(errorCount-lastErrorCount), name);
+                sprintf(msg,  "   } ERRORS (%li) in %s", (long)(errorCount-lastErrorCount), name);
+                if(!no_time) str_timeDelta(msg+strlen(msg),timeStop-timeStart);

 
                 for(int i=0;i<LL_indentlevel;i++) {
                     errorList += " ";
 
                 for(int i=0;i<LL_indentlevel;i++) {
                     errorList += " ";


@@ -679,6 +775,8 @@ UBool IntlTest::runTestLoop( char* testname, char* par )
         index++;
     }while(name);
 
         index++;
     }while(name);
 

+    *saveBaseLoc = 0;
+

     gTest = saveTest;
     return rval;
 }
     gTest = saveTest;
     return rval;
 }


@@ -779,12 +877,23 @@ void IntlTest::dataerr( const UnicodeString &message )
 void IntlTest::dataerrln( const UnicodeString &message )
 {
     IncDataErrorCount();
 void IntlTest::dataerrln( const UnicodeString &message )
 {
     IncDataErrorCount();

-
+    UnicodeString msg;

     if (!warn_on_missing_data) {
         IncErrorCount();
     if (!warn_on_missing_data) {
         IncErrorCount();

+        msg = message;
+    } else {
+        msg = UnicodeString("[DATA] " + message);

     }
 
     }
 

-    if (!no_err_msg) LL_message( message, TRUE );
+    if (!no_err_msg) LL_message( msg + " - (Are you missing data?)", TRUE );
+}
+
+void IntlTest::errcheckln(UErrorCode status, const UnicodeString &message ) {
+    if (status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR) {
+        dataerrln(message);
+    } else {
+        errln(message);
+    }

 }
 
 /* convenience functions that include sprintf formatting */
 }
 
 /* convenience functions that include sprintf formatting */


@@ -874,6 +983,22 @@ void IntlTest::dataerrln(const char *fmt, ...)
     dataerrln(UnicodeString(buffer, ""));
 }
 
     dataerrln(UnicodeString(buffer, ""));
 }
 

+void IntlTest::errcheckln(UErrorCode status, const char *fmt, ...)
+{
+    char buffer[4000];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(buffer, fmt, ap);
+    va_end(ap);
+    
+    if (status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR) {
+        dataerrln(UnicodeString(buffer, ""));
+    } else {
+        errln(UnicodeString(buffer, ""));
+    }
+}
+

 void IntlTest::printErrors()
 {
      IntlTest::LL_message(errorList, TRUE);
 void IntlTest::printErrors()
 {
      IntlTest::LL_message(errorList, TRUE);


@@ -974,20 +1099,24 @@ main(int argc, char* argv[])
     UBool all = FALSE;
     UBool verbose = FALSE;
     UBool no_err_msg = FALSE;
     UBool all = FALSE;
     UBool verbose = FALSE;
     UBool no_err_msg = FALSE;

+    UBool no_time = FALSE;

     UBool quick = TRUE;
     UBool name = FALSE;
     UBool leaks = FALSE;
     UBool warnOnMissingData = FALSE;
     UBool defaultDataFound = FALSE;
     UBool quick = TRUE;
     UBool name = FALSE;
     UBool leaks = FALSE;
     UBool warnOnMissingData = FALSE;
     UBool defaultDataFound = FALSE;

+    int32_t threadCount = 1;

     UErrorCode errorCode = U_ZERO_ERROR;
     UConverter *cnv = NULL;
     const char *warnOrErr = "Failure";
     UDate startTime, endTime;
     int32_t diffTime;
     UErrorCode errorCode = U_ZERO_ERROR;
     UConverter *cnv = NULL;
     const char *warnOrErr = "Failure";
     UDate startTime, endTime;
     int32_t diffTime;

+    const char *props[IntlTest::kMaxProps];
+    int32_t nProps = 0;

 
     U_MAIN_INIT_ARGS(argc, argv);
 
 
     U_MAIN_INIT_ARGS(argc, argv);
 

-    startTime = uprv_getUTCtime();
+    startTime = uprv_getRawUTCtime();

 
     for (int i = 1; i < argc; ++i) {
         if (argv[i][0] == '-') {
 
     for (int i = 1; i < argc; ++i) {
         if (argv[i][0] == '-') {


@@ -1007,10 +1136,30 @@ main(int argc, char* argv[])
             else if (strcmp("leaks", str) == 0 ||
                      strcmp("l", str) == 0)
                 leaks = TRUE;
             else if (strcmp("leaks", str) == 0 ||
                      strcmp("l", str) == 0)
                 leaks = TRUE;

-            else if (strcmp("w", str) == 0) {
+            else if (strcmp("notime", str) == 0 ||
+                     strcmp("T", str) == 0)
+                no_time = TRUE;
+            else if (strcmp("x", str)==0) {
+              if(++i>=argc) {
+                printf("* Error: '-x' option requires an argument. usage: '-x outfile.xml'.\n");
+                syntax = TRUE;
+              }
+              if(ctest_xml_setFileName(argv[i])) { /* set the name */
+                return 1; /* error */
+              }
+            } else if (strcmp("w", str) == 0) {

               warnOnMissingData = TRUE;
               warnOrErr = "WARNING";
             }
               warnOnMissingData = TRUE;
               warnOrErr = "WARNING";
             }

+            else if (strncmp("threads:", str, 8) == 0) {
+                threadCount = atoi(str + 8);
+            }
+            else if (strncmp("prop:", str, 5) == 0) {
+                if (nProps < IntlTest::kMaxProps) {
+                    props[nProps] = str + 5;
+                }
+                nProps++;
+            }

             else {
                 syntax = TRUE;
             }
             else {
                 syntax = TRUE;
             }


@@ -1029,8 +1178,13 @@ main(int argc, char* argv[])
         fprintf(stdout,
                 "### Syntax:\n"
                 "### IntlTest [-option1 -option2 ...] [testname1 testname2 ...] \n"
         fprintf(stdout,
                 "### Syntax:\n"
                 "### IntlTest [-option1 -option2 ...] [testname1 testname2 ...] \n"

-                "### where options are: verbose (v), all (a), noerrormsg (n), \n"
-                "### exhaustive (e), leaks (l)"
+                "### \n"
+                "### Options are: verbose (v), all (a), noerrormsg (n), \n"
+                "### exhaustive (e), leaks (l), -x xmlfile.xml, prop:<propery>=<value>, \n"
+                "### notime (T), \n"
+                "### threads:<threadCount> (Mulithreading must first be \n"
+                "###     enabled otherwise this will be ignored. \n"
+                "###     The default thread count is 1.),\n"

                 "### (Specify either -all (shortcut -a) or a test name). \n"
                 "### -all will run all of the tests.\n"
                 "### \n"
                 "### (Specify either -all (shortcut -a) or a test name). \n"
                 "### -all will run all of the tests.\n"
                 "### \n"


@@ -1046,16 +1200,43 @@ main(int argc, char* argv[])
         return 1;
     }
 
         return 1;
     }
 

+    if (nProps > IntlTest::kMaxProps) {
+        fprintf(stdout, "### Too many properties.  Exiting.\n");
+    }
+

     UBool all_tests_exist = TRUE;
     MajorTestLevel major;
     major.setVerbose( verbose );
     major.setNoErrMsg( no_err_msg );
     major.setQuick( quick );
     major.setLeaks( leaks );
     UBool all_tests_exist = TRUE;
     MajorTestLevel major;
     major.setVerbose( verbose );
     major.setNoErrMsg( no_err_msg );
     major.setQuick( quick );
     major.setLeaks( leaks );

+    major.setThreadCount( threadCount );

     major.setWarnOnMissingData( warnOnMissingData );
     major.setWarnOnMissingData( warnOnMissingData );

+    major.setNotime (no_time);
+    for (int32_t i = 0; i < nProps; i++) {
+        major.setProperty(props[i]);
+    }
+
+

     fprintf(stdout, "-----------------------------------------------\n");
     fprintf(stdout, " IntlTest (C++) Test Suite for                 \n");
     fprintf(stdout, "   International Components for Unicode %s\n", U_ICU_VERSION);
     fprintf(stdout, "-----------------------------------------------\n");
     fprintf(stdout, " IntlTest (C++) Test Suite for                 \n");
     fprintf(stdout, "   International Components for Unicode %s\n", U_ICU_VERSION);

+
+
+    {
+       const char *charsetFamily = "Unknown";
+        int32_t voidSize = (int32_t)sizeof(void*);
+        int32_t bits = voidSize * 8;
+        if(U_CHARSET_FAMILY==U_ASCII_FAMILY) {
+           charsetFamily="ASCII";
+        } else if(U_CHARSET_FAMILY==U_EBCDIC_FAMILY) {
+           charsetFamily="EBCDIC";
+        }
+        fprintf(stdout, 
+                    "   Bits: %d, Byte order: %s, Chars: %s\n",
+                     bits, U_IS_BIG_ENDIAN?"Big endian":"Little endian",
+                     charsetFamily);
+    }

     fprintf(stdout, "-----------------------------------------------\n");
     fprintf(stdout, " Options:                                       \n");
     fprintf(stdout, "   all (a)                  : %s\n", (all?               "On" : "Off"));
     fprintf(stdout, "-----------------------------------------------\n");
     fprintf(stdout, " Options:                                       \n");
     fprintf(stdout, "   all (a)                  : %s\n", (all?               "On" : "Off"));


@@ -1063,7 +1244,16 @@ main(int argc, char* argv[])
     fprintf(stdout, "   No error messages (n)    : %s\n", (no_err_msg?        "On" : "Off"));
     fprintf(stdout, "   Exhaustive (e)           : %s\n", (!quick?            "On" : "Off"));
     fprintf(stdout, "   Leaks (l)                : %s\n", (leaks?             "On" : "Off"));
     fprintf(stdout, "   No error messages (n)    : %s\n", (no_err_msg?        "On" : "Off"));
     fprintf(stdout, "   Exhaustive (e)           : %s\n", (!quick?            "On" : "Off"));
     fprintf(stdout, "   Leaks (l)                : %s\n", (leaks?             "On" : "Off"));

+    fprintf(stdout, "   notime (T)               : %s\n", (no_time?             "On" : "Off"));

     fprintf(stdout, "   Warn on missing data (w) : %s\n", (warnOnMissingData? "On" : "Off"));
     fprintf(stdout, "   Warn on missing data (w) : %s\n", (warnOnMissingData? "On" : "Off"));

+#if (ICU_USE_THREADS==0)
+    fprintf(stdout, "   Threads                  : Disabled\n");
+#else
+    fprintf(stdout, "   Threads                  : %d\n", threadCount);
+#endif
+    for (int32_t i = 0; i < nProps; i++) {
+        fprintf(stdout, "   Custom property (prop:)  : %s\n", props[i]);
+    }

     fprintf(stdout, "-----------------------------------------------\n");
 
     /* Check whether ICU will initialize without forcing the build data directory into
     fprintf(stdout, "-----------------------------------------------\n");
 
     /* Check whether ICU will initialize without forcing the build data directory into


@@ -1153,6 +1343,10 @@ main(int argc, char* argv[])
 
     Locale originalLocale;  // Save the default locale for comparison later on.
 
 
     Locale originalLocale;  // Save the default locale for comparison later on.
 

+    if(ctest_xml_init("intltest")) 
+      return 1;
+
+

     /* TODO: Add option to call u_cleanup and rerun tests. */
     if (all) {
         major.runTest();
     /* TODO: Add option to call u_cleanup and rerun tests. */
     if (all) {
         major.runTest();


@@ -1164,13 +1358,17 @@ main(int argc, char* argv[])
             if (argv[i][0] != '-') {
                 char* name = argv[i];
                 fprintf(stdout, "\n=== Handling test: %s: ===\n", name);
             if (argv[i][0] != '-') {
                 char* name = argv[i];
                 fprintf(stdout, "\n=== Handling test: %s: ===\n", name);

+
+                char baseName[1024];
+                sprintf(baseName, "/%s/", name);
+

                 char* parameter = strchr( name, '@' );
                 if (parameter) {
                     *parameter = 0;
                     parameter += 1;
                 }
                 execCount = 0;
                 char* parameter = strchr( name, '@' );
                 if (parameter) {
                     *parameter = 0;
                     parameter += 1;
                 }
                 execCount = 0;

-                UBool res = major.runTest( name, parameter );
+                UBool res = major.runTest( name, parameter, baseName );

                 if (leaks && res) {
                     major.run_phase2( name, parameter );
                 }
                 if (leaks && res) {
                     major.run_phase2( name, parameter );
                 }


@@ -1178,10 +1376,13 @@ main(int argc, char* argv[])
                     fprintf(stdout, "\n---ERROR: Test doesn't exist: %s!\n", name);
                     all_tests_exist = FALSE;
                 }
                     fprintf(stdout, "\n---ERROR: Test doesn't exist: %s!\n", name);
                     all_tests_exist = FALSE;
                 }

+            } else if(!strcmp(argv[i],"-x")) {
+              i++;

             }
         }
     }
 
             }
         }
     }
 

+

 #if !UCONFIG_NO_FORMATTING
     CalendarTimeZoneTest::cleanup();
 #endif
 #if !UCONFIG_NO_FORMATTING
     CalendarTimeZoneTest::cleanup();
 #endif


@@ -1226,13 +1427,19 @@ main(int argc, char* argv[])
     if (execCount <= 0) {
         fprintf(stdout, "***** Not all called tests actually exist! *****\n");
     }
     if (execCount <= 0) {
         fprintf(stdout, "***** Not all called tests actually exist! *****\n");
     }

-    endTime = uprv_getUTCtime();
-    diffTime = (int32_t)(endTime - startTime);
-    printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
-        (int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
-        (int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
-        (int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
-        (int)(diffTime%U_MILLIS_PER_SECOND));
+    if(!no_time) {
+      endTime = uprv_getRawUTCtime();
+      diffTime = (int32_t)(endTime - startTime);
+      printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
+             (int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
+             (int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
+             (int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
+             (int)(diffTime%U_MILLIS_PER_SECOND));
+    }
+
+    if(ctest_xml_fini())
+      return 1;
+

     return major.getErrors();
 }
 
     return major.getErrors();
 }
 


@@ -1244,10 +1451,10 @@ const char* IntlTest::loadTestData(UErrorCode& err){
         const char* tdrelativepath;
 
 #if defined (U_TOPBUILDDIR)
         const char* tdrelativepath;
 
 #if defined (U_TOPBUILDDIR)

-        tdrelativepath = "test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"out"U_FILE_SEP_STRING;
+        tdrelativepath = "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;

         directory = U_TOPBUILDDIR;
 #else
         directory = U_TOPBUILDDIR;
 #else

-        tdrelativepath = ".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"out"U_FILE_SEP_STRING;
+        tdrelativepath = ".." U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;

         directory = pathToDataDirectory();
 #endif
 
         directory = pathToDataDirectory();
 #endif
 


@@ -1265,7 +1472,7 @@ const char* IntlTest::loadTestData(UErrorCode& err){
 
         if(U_FAILURE(err)){
             err = U_FILE_ACCESS_ERROR;
 
         if(U_FAILURE(err)){
             err = U_FILE_ACCESS_ERROR;

-            it_errln((UnicodeString)"Could not load testtypes.res in testdata bundle with path " + tdpath + (UnicodeString)" - " + u_errorName(err));
+            it_dataerrln((UnicodeString)"Could not load testtypes.res in testdata bundle with path " + tdpath + (UnicodeString)" - " + u_errorName(err));

             return "";
         }
         ures_close(test);
             return "";
         }
         ures_close(test);


@@ -1283,17 +1490,17 @@ const char* IntlTest::getTestDataPath(UErrorCode& err) {
 const char *IntlTest::getSourceTestData(UErrorCode& /*err*/) {
     const char *srcDataDir = NULL;
 #ifdef U_TOPSRCDIR
 const char *IntlTest::getSourceTestData(UErrorCode& /*err*/) {
     const char *srcDataDir = NULL;
 #ifdef U_TOPSRCDIR

-    srcDataDir = U_TOPSRCDIR U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING;
+    srcDataDir = U_TOPSRCDIR U_FILE_SEP_STRING"test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING;

 #else
 #else

-    srcDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING;
-    FILE *f = fopen(".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"rbbitst.txt", "r");
+    srcDataDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING;
+    FILE *f = fopen(".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "rbbitst.txt", "r");

     if (f) {
         /* We're in icu/source/test/intltest/ */
         fclose(f);
     }
     else {
     if (f) {
         /* We're in icu/source/test/intltest/ */
         fclose(f);
     }
     else {

-        /* We're in icu/source/test/intltest/(Debug|Release) */
-        srcDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING;
+        /* We're in icu/source/test/intltest/Platform/(Debug|Release) */
+        srcDataDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata"U_FILE_SEP_STRING;

     }
 #endif
     return srcDataDir;
     }
 #endif
     return srcDataDir;


@@ -1351,13 +1558,13 @@ const char *  IntlTest::pathToDataDirectory()
         }
         else {
             /* __FILE__ on MSVC7 does not contain the directory */
         }
         else {
             /* __FILE__ on MSVC7 does not contain the directory */

-            FILE *file = fopen(".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r");
+            FILE *file = fopen(".." U_FILE_SEP_STRING ".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r");

             if (file) {
                 fclose(file);
             if (file) {
                 fclose(file);

-                fgDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
+                fgDataDir = ".." U_FILE_SEP_STRING ".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;

             }
             else {
             }
             else {

-                fgDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
+                fgDataDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;

             }
         }
     }
             }
         }
     }


@@ -1369,13 +1576,11 @@ const char *  IntlTest::pathToDataDirectory()
 
 /*
  * This is a variant of cintltst/ccolltst.c:CharsToUChars().
 
 /*
  * This is a variant of cintltst/ccolltst.c:CharsToUChars().

- * It converts a character string into a UnicodeString, with
+ * It converts an invariant-character string into a UnicodeString, with

  * unescaping \u sequences.
  */
  * unescaping \u sequences.
  */

-UnicodeString CharsToUnicodeString(const char* chars)
-{
-    UnicodeString str(chars, ""); // Invariant conversion
-    return str.unescape();
+UnicodeString CharsToUnicodeString(const char* chars){
+    return UnicodeString(chars, -1, US_INV).unescape();

 }
 
 UnicodeString ctou(const char* chars) {
 }
 
 UnicodeString ctou(const char* chars) {


@@ -1449,11 +1654,28 @@ static UnicodeString& escape(const UnicodeString& s, UnicodeString& result) {
 
 #define VERBOSE_ASSERTIONS
 
 
 #define VERBOSE_ASSERTIONS
 

-UBool IntlTest::assertTrue(const char* message, UBool condition, UBool quiet) {
-    if (!condition) {
-        errln("FAIL: assertTrue() failed: %s", message);
-    } else if (!quiet) {
-        logln("Ok: %s", message);
+UBool IntlTest::assertTrue(const char* message, UBool condition, UBool quiet, UBool possibleDataError, const char *file, int line) {
+    if (file != NULL) {
+        if (!condition) {
+            if (possibleDataError) {
+                dataerrln("%s:%d: FAIL: assertTrue() failed: %s", file, line, message);
+            } else {
+                errln("%s:%d: FAIL: assertTrue() failed: %s", file, line, message);
+            }
+        } else if (!quiet) {
+            logln("%s:%d: Ok: %s", file, line, message);
+        }
+    } else {
+        if (!condition) {
+            if (possibleDataError) {
+                dataerrln("FAIL: assertTrue() failed: %s", message);
+            } else {
+                errln("FAIL: assertTrue() failed: %s", message);
+            }
+        } else if (!quiet) {
+            logln("Ok: %s", message);
+        }
+

     }
     return condition;
 }
     }
     return condition;
 }


@@ -1467,9 +1689,14 @@ UBool IntlTest::assertFalse(const char* message, UBool condition, UBool quiet) {
     return !condition;
 }
 
     return !condition;
 }
 

-UBool IntlTest::assertSuccess(const char* message, UErrorCode ec) {
+UBool IntlTest::assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError) {

     if (U_FAILURE(ec)) {
     if (U_FAILURE(ec)) {

-        errln("FAIL: %s (%s)", message, u_errorName(ec));
+        if (possibleDataError) {
+            dataerrln("FAIL: %s (%s)", message, u_errorName(ec));
+        } else {
+            errcheckln(ec, "FAIL: %s (%s)", message, u_errorName(ec));
+        }
+        

         return FALSE;
     }
     return TRUE;
         return FALSE;
     }
     return TRUE;


@@ -1477,11 +1704,18 @@ UBool IntlTest::assertSuccess(const char* message, UErrorCode ec) {
 
 UBool IntlTest::assertEquals(const char* message,
                              const UnicodeString& expected,
 
 UBool IntlTest::assertEquals(const char* message,
                              const UnicodeString& expected,

-                             const UnicodeString& actual) {
+                             const UnicodeString& actual,
+                             UBool possibleDataError) {

     if (expected != actual) {
     if (expected != actual) {

-        errln((UnicodeString)"FAIL: " + message + "; got " +
-              prettify(actual) +
-              "; expected " + prettify(expected));
+        if (possibleDataError) {
+            dataerrln((UnicodeString)"FAIL: " + message + "; got " +
+                  prettify(actual) +
+                  "; expected " + prettify(expected));
+        } else {
+            errln((UnicodeString)"FAIL: " + message + "; got " +
+                  prettify(actual) +
+                  "; expected " + prettify(expected));
+        }

         return FALSE;
     }
 #ifdef VERBOSE_ASSERTIONS
         return FALSE;
     }
 #ifdef VERBOSE_ASSERTIONS


@@ -1509,6 +1743,23 @@ UBool IntlTest::assertEquals(const char* message,
     return TRUE;
 }
 
     return TRUE;
 }
 

+UBool IntlTest::assertEquals(const char* message,
+                             int32_t expected,
+                             int32_t actual) {
+    if (expected != actual) {
+        errln((UnicodeString)"FAIL: " + message + "; got " +
+              actual + "=0x" + toHex(actual) +
+              "; expected " + expected + "=0x" + toHex(expected));
+        return FALSE;
+    }
+#ifdef VERBOSE_ASSERTIONS
+    else {
+        logln((UnicodeString)"Ok: " + message + "; got " + actual + "=0x" + toHex(actual));
+    }
+#endif
+    return TRUE;
+}
+

 #if !UCONFIG_NO_FORMATTING
 UBool IntlTest::assertEquals(const char* message,
                              const Formattable& expected,
 #if !UCONFIG_NO_FORMATTING
 UBool IntlTest::assertEquals(const char* message,
                              const Formattable& expected,


@@ -1566,10 +1817,11 @@ UBool IntlTest::assertEquals(const UnicodeString& message,
 //             release
 //--------------------------------------------------------------------
 
 //             release
 //--------------------------------------------------------------------
 

-UBool IntlTest::isICUVersionAtLeast(const UVersionInfo x) {
-    UVersionInfo v;
-    u_getVersion(v);
-    return (uprv_memcmp(v, x, U_MAX_VERSION_LENGTH) >= 0);
+UBool IntlTest::isICUVersionBefore(int major, int minor, int milli) {
+    UVersionInfo iv;
+    UVersionInfo ov = { (uint8_t)major, (uint8_t)minor, (uint8_t)milli, 0 };
+    u_getVersion(iv);
+    return uprv_memcmp(iv, ov, U_MAX_VERSION_LENGTH) < 0;

 }
 
 #if !UCONFIG_NO_FORMATTING
 }
 
 #if !UCONFIG_NO_FORMATTING


@@ -1580,6 +1832,27 @@ UBool IntlTest::assertEquals(const UnicodeString& message,
 }
 #endif
 
 }
 #endif
 

+void IntlTest::setProperty(const char* propline) {
+    if (numProps < kMaxProps) {
+        proplines[numProps] = propline;
+    }
+    numProps++;
+}
+
+const char* IntlTest::getProperty(const char* prop) {
+    const char* val = NULL;
+    for (int32_t i = 0; i < numProps; i++) {
+        int32_t plen = uprv_strlen(prop);
+        if ((int32_t)uprv_strlen(proplines[i]) > plen + 1
+                && proplines[i][plen] == '='
+                && uprv_strncmp(proplines[i], prop, plen) == 0) {
+            val = &(proplines[i][plen+1]);
+            break;
+        }
+    }
+    return val;
+}
+

 /*
  * Hey, Emacs, please set the following:
  *
 /*
  * Hey, Emacs, please set the following:
  *