1 /******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 1997-2010, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6 7 8 #include "unicode/utypes.h" 9 10 /** 11 * IntlTest is a base class for tests. 12 */ 13 14 #include <stdio.h> 15 #include <string.h> 16 #include <assert.h> 17 #include <stdarg.h> 18 #include <stdlib.h> 19 20 #include "unicode/unistr.h" 21 #include "unicode/ures.h" 22 #include "unicode/smpdtfmt.h" 23 #include "unicode/ucnv.h" 24 #include "unicode/uclean.h" 25 #include "unicode/timezone.h" 26 #include "unicode/curramt.h" 27 #include "unicode/putil.h" 28 29 #include "intltest.h" 30 #include "caltztst.h" 31 #include "itmajor.h" 32 #include "cstring.h" 33 #include "umutex.h" 34 #include "uassert.h" 35 #include "cmemory.h" 36 #include "uoptions.h" 37 38 #include "putilimp.h" // for uprv_getRawUTCtime() 39 #include "unicode/locid.h" 40 #include "unicode/ctest.h" // for str_timeDelta 41 42 #ifdef XP_MAC_CONSOLE 43 #include <console.h> 44 #include "Files.h" 45 #endif 46 47 48 static char* _testDataPath=NULL; 49 50 // Static list of errors found 51 static UnicodeString errorList; 52 53 //----------------------------------------------------------------------------- 54 //convenience classes to ease porting code that uses the Java 55 //string-concatenation operator (moved from findword test by rtg) 56 57 // [LIU] Just to get things working 58 UnicodeString 59 UCharToUnicodeString(UChar c) 60 { return UnicodeString(c); } 61 62 // [rtg] Just to get things working 63 UnicodeString 64 operator+(const UnicodeString& left, 65 long num) 66 { 67 char buffer[64]; // nos changed from 10 to 64 68 char danger = 'p'; // guard against overrunning the buffer (rtg) 69 70 sprintf(buffer, "%ld", num); 71 assert(danger == 'p'); 72 73 return left + buffer; 74 } 75 76 UnicodeString 77 operator+(const UnicodeString& left, 78 unsigned long num) 79 { 80 char buffer[64]; // nos changed from 10 to 64 81 char danger = 'p'; // guard against overrunning the buffer (rtg) 82 83 sprintf(buffer, "%lu", num); 84 assert(danger == 'p'); 85 86 return left + buffer; 87 } 88 89 UnicodeString 90 Int64ToUnicodeString(int64_t num) 91 { 92 char buffer[64]; // nos changed from 10 to 64 93 char danger = 'p'; // guard against overrunning the buffer (rtg) 94 95 #ifdef U_WINDOWS 96 sprintf(buffer, "%I64d", num); 97 #else 98 sprintf(buffer, "%lld", (long long)num); 99 #endif 100 assert(danger == 'p'); 101 102 return buffer; 103 } 104 105 // [LIU] Just to get things working 106 UnicodeString 107 operator+(const UnicodeString& left, 108 double num) 109 { 110 char buffer[64]; // was 32, made it arbitrarily bigger (rtg) 111 char danger = 'p'; // guard against overrunning the buffer (rtg) 112 113 // IEEE floating point has 52 bits of mantissa, plus one assumed bit 114 // 53*log(2)/log(10) = 15.95 115 // so there is no need to show more than 16 digits. [alan] 116 117 sprintf(buffer, "%.17g", num); 118 assert(danger == 'p'); 119 120 return left + buffer; 121 } 122 123 #if !UCONFIG_NO_FORMATTING 124 125 /** 126 * Return a string display for this, without surrounding braces. 127 */ 128 UnicodeString _toString(const Formattable& f) { 129 UnicodeString s; 130 switch (f.getType()) { 131 case Formattable::kDate: 132 { 133 UErrorCode status = U_ZERO_ERROR; 134 SimpleDateFormat fmt(status); 135 if (U_SUCCESS(status)) { 136 FieldPosition pos; 137 fmt.format(f.getDate(), s, pos); 138 s.insert(0, "Date:"); 139 } else { 140 s = UnicodeString("Error creating date format]"); 141 } 142 } 143 break; 144 case Formattable::kDouble: 145 s = UnicodeString("double:") + f.getDouble(); 146 break; 147 case Formattable::kLong: 148 s = UnicodeString("long:") + f.getLong(); 149 break; 150 151 case Formattable::kInt64: 152 s = UnicodeString("int64:") + Int64ToUnicodeString(f.getInt64()); 153 break; 154 155 case Formattable::kString: 156 f.getString(s); 157 s.insert(0, "String:"); 158 break; 159 case Formattable::kArray: 160 { 161 int32_t i, n; 162 const Formattable* array = f.getArray(n); 163 s.insert(0, UnicodeString("Array:")); 164 UnicodeString delim(", "); 165 for (i=0; i<n; ++i) { 166 if (i > 0) { 167 s.append(delim); 168 } 169 s = s + _toString(array[i]); 170 } 171 } 172 break; 173 case Formattable::kObject: { 174 const CurrencyAmount* c = dynamic_cast<const CurrencyAmount*>(f.getObject()); 175 if (c != NULL) { 176 s = _toString(c->getNumber()) + " " + UnicodeString(c->getISOCurrency()); 177 } else { 178 s = UnicodeString("Unknown UObject"); 179 } 180 break; 181 } 182 default: 183 s = UnicodeString("Unknown Formattable type=") + (int32_t)f.getType(); 184 break; 185 } 186 return s; 187 } 188 189 /** 190 * Originally coded this as operator+, but that makes the expression 191 * + char* ambiguous. - liu 192 */ 193 UnicodeString toString(const Formattable& f) { 194 UnicodeString s((UChar)91/*[*/); 195 s.append(_toString(f)); 196 s.append((UChar)0x5d/*]*/); 197 return s; 198 } 199 200 #endif 201 202 // useful when operator+ won't cooperate 203 UnicodeString toString(int32_t n) { 204 return UnicodeString() + (long)n; 205 } 206 207 // stephen - cleaned up 05/05/99 208 UnicodeString operator+(const UnicodeString& left, char num) 209 { return left + (long)num; } 210 UnicodeString operator+(const UnicodeString& left, short num) 211 { return left + (long)num; } 212 UnicodeString operator+(const UnicodeString& left, int num) 213 { return left + (long)num; } 214 UnicodeString operator+(const UnicodeString& left, unsigned char num) 215 { return left + (unsigned long)num; } 216 UnicodeString operator+(const UnicodeString& left, unsigned short num) 217 { return left + (unsigned long)num; } 218 UnicodeString operator+(const UnicodeString& left, unsigned int num) 219 { return left + (unsigned long)num; } 220 UnicodeString operator+(const UnicodeString& left, float num) 221 { return left + (double)num; } 222 223 //------------------ 224 225 // Append a hex string to the target 226 UnicodeString& 227 IntlTest::appendHex(uint32_t number, 228 int32_t digits, 229 UnicodeString& target) 230 { 231 static const UChar digitString[] = { 232 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 233 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0 234 }; /* "0123456789ABCDEF" */ 235 236 switch (digits) 237 { 238 case 8: 239 target += digitString[(number >> 28) & 0xF]; 240 case 7: 241 target += digitString[(number >> 24) & 0xF]; 242 case 6: 243 target += digitString[(number >> 20) & 0xF]; 244 case 5: 245 target += digitString[(number >> 16) & 0xF]; 246 case 4: 247 target += digitString[(number >> 12) & 0xF]; 248 case 3: 249 target += digitString[(number >> 8) & 0xF]; 250 case 2: 251 target += digitString[(number >> 4) & 0xF]; 252 case 1: 253 target += digitString[(number >> 0) & 0xF]; 254 break; 255 default: 256 target += "**"; 257 } 258 return target; 259 } 260 261 static inline UBool isPrintable(UChar32 c) { 262 return c <= 0x7E && (c >= 0x20 || c == 9 || c == 0xA || c == 0xD); 263 } 264 265 // Replace nonprintable characters with unicode escapes 266 UnicodeString& 267 IntlTest::prettify(const UnicodeString &source, 268 UnicodeString &target) 269 { 270 int32_t i; 271 272 target.remove(); 273 target += "\""; 274 275 for (i = 0; i < source.length(); ) 276 { 277 UChar32 ch = source.char32At(i); 278 i += U16_LENGTH(ch); 279 280 if (!isPrintable(ch)) 281 { 282 if (ch <= 0xFFFF) { 283 target += "\\u"; 284 appendHex(ch, 4, target); 285 } else { 286 target += "\\U"; 287 appendHex(ch, 8, target); 288 } 289 } 290 else 291 { 292 target += ch; 293 } 294 } 295 296 target += "\""; 297 298 return target; 299 } 300 301 // Replace nonprintable characters with unicode escapes 302 UnicodeString 303 IntlTest::prettify(const UnicodeString &source, UBool parseBackslash) 304 { 305 int32_t i; 306 UnicodeString target; 307 target.remove(); 308 target += "\""; 309 310 for (i = 0; i < source.length();) 311 { 312 UChar32 ch = source.char32At(i); 313 i += U16_LENGTH(ch); 314 315 if (!isPrintable(ch)) 316 { 317 if (parseBackslash) { 318 // If we are preceded by an odd number of backslashes, 319 // then this character has already been backslash escaped. 320 // Delete a backslash. 321 int32_t backslashCount = 0; 322 for (int32_t j=target.length()-1; j>=0; --j) { 323 if (target.charAt(j) == (UChar)92) { 324 ++backslashCount; 325 } else { 326 break; 327 } 328 } 329 if ((backslashCount % 2) == 1) { 330 target.truncate(target.length() - 1); 331 } 332 } 333 if (ch <= 0xFFFF) { 334 target += "\\u"; 335 appendHex(ch, 4, target); 336 } else { 337 target += "\\U"; 338 appendHex(ch, 8, target); 339 } 340 } 341 else 342 { 343 target += ch; 344 } 345 } 346 347 target += "\""; 348 349 return target; 350 } 351 352 /* IntlTest::setICU_DATA - if the ICU_DATA environment variable is not already 353 * set, try to deduce the directory in which ICU was built, 354 * and set ICU_DATA to "icu/source/data" in that location. 355 * The intent is to allow the tests to have a good chance 356 * of running without requiring that the user manually set 357 * ICU_DATA. Common data isn't a problem, since it is 358 * picked up via a static (build time) reference, but the 359 * tests dynamically load some data. 360 */ 361 void IntlTest::setICU_DATA() { 362 const char *original_ICU_DATA = getenv("ICU_DATA"); 363 364 if (original_ICU_DATA != NULL && *original_ICU_DATA != 0) { 365 /* If the user set ICU_DATA, don't second-guess the person. */ 366 return; 367 } 368 369 // U_TOPBUILDDIR is set by the makefiles on UNIXes when building cintltst and intltst 370 // to point to the top of the build hierarchy, which may or 371 // may not be the same as the source directory, depending on 372 // the configure options used. At any rate, 373 // set the data path to the built data from this directory. 374 // The value is complete with quotes, so it can be used 375 // as-is as a string constant. 376 377 #if defined (U_TOPBUILDDIR) 378 { 379 static char env_string[] = U_TOPBUILDDIR "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING; 380 u_setDataDirectory(env_string); 381 return; 382 } 383 384 #else 385 // Use #else so we don't get compiler warnings due to the return above. 386 387 /* On Windows, the file name obtained from __FILE__ includes a full path. 388 * This file is "wherever\icu\source\test\cintltst\cintltst.c" 389 * Change to "wherever\icu\source\data" 390 */ 391 { 392 char p[sizeof(__FILE__) + 10]; 393 char *pBackSlash; 394 int i; 395 396 strcpy(p, __FILE__); 397 /* We want to back over three '\' chars. */ 398 /* Only Windows should end up here, so looking for '\' is safe. */ 399 for (i=1; i<=3; i++) { 400 pBackSlash = strrchr(p, U_FILE_SEP_CHAR); 401 if (pBackSlash != NULL) { 402 *pBackSlash = 0; /* Truncate the string at the '\' */ 403 } 404 } 405 406 if (pBackSlash != NULL) { 407 /* We found and truncated three names from the path. 408 * Now append "source\data" and set the environment 409 */ 410 strcpy(pBackSlash, U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING); 411 u_setDataDirectory(p); /* p is "ICU_DATA=wherever\icu\source\data" */ 412 return; 413 } 414 else { 415 /* __FILE__ on MSVC7 does not contain the directory */ 416 u_setDataDirectory(".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING); 417 return; 418 } 419 } 420 #endif 421 422 /* No location for the data dir was identifiable. 423 * Add other fallbacks for the test data location here if the need arises 424 */ 425 } 426 427 428 //-------------------------------------------------------------------------------------- 429 430 static const int32_t indentLevel_offset = 3; 431 static const char delim = '/'; 432 433 IntlTest* IntlTest::gTest = NULL; 434 435 static int32_t execCount = 0; 436 437 void it_log( UnicodeString message ) 438 { 439 if (IntlTest::gTest) 440 IntlTest::gTest->log( message ); 441 } 442 443 void it_logln( UnicodeString message ) 444 { 445 if (IntlTest::gTest) 446 IntlTest::gTest->logln( message ); 447 } 448 449 void it_logln( void ) 450 { 451 if (IntlTest::gTest) 452 IntlTest::gTest->logln(); 453 } 454 455 void it_info( UnicodeString message ) 456 { 457 if (IntlTest::gTest) 458 IntlTest::gTest->info( message ); 459 } 460 461 void it_infoln( UnicodeString message ) 462 { 463 if (IntlTest::gTest) 464 IntlTest::gTest->infoln( message ); 465 } 466 467 void it_infoln( void ) 468 { 469 if (IntlTest::gTest) 470 IntlTest::gTest->infoln(); 471 } 472 473 void it_err() 474 { 475 if (IntlTest::gTest) 476 IntlTest::gTest->err(); 477 } 478 479 void it_err( UnicodeString message ) 480 { 481 if (IntlTest::gTest) 482 IntlTest::gTest->err( message ); 483 } 484 485 void it_errln( UnicodeString message ) 486 { 487 if (IntlTest::gTest) 488 IntlTest::gTest->errln( message ); 489 } 490 491 void it_dataerr( UnicodeString message ) 492 { 493 if (IntlTest::gTest) 494 IntlTest::gTest->dataerr( message ); 495 } 496 497 void it_dataerrln( UnicodeString message ) 498 { 499 if (IntlTest::gTest) 500 IntlTest::gTest->dataerrln( message ); 501 } 502 503 IntlTest::IntlTest() 504 { 505 caller = NULL; 506 testPath = NULL; 507 LL_linestart = TRUE; 508 errorCount = 0; 509 dataErrorCount = 0; 510 verbose = FALSE; 511 no_err_msg = FALSE; 512 warn_on_missing_data = FALSE; 513 quick = FALSE; 514 leaks = FALSE; 515 threadCount = 1; 516 testoutfp = stdout; 517 LL_indentlevel = indentLevel_offset; 518 numProps = 0; 519 strcpy(basePath, "/"); 520 } 521 522 void IntlTest::setCaller( IntlTest* callingTest ) 523 { 524 caller = callingTest; 525 if (caller) { 526 warn_on_missing_data = caller->warn_on_missing_data; 527 verbose = caller->verbose; 528 no_err_msg = caller->no_err_msg; 529 quick = caller->quick; 530 testoutfp = caller->testoutfp; 531 LL_indentlevel = caller->LL_indentlevel + indentLevel_offset; 532 numProps = caller->numProps; 533 for (int32_t i = 0; i < numProps; i++) { 534 proplines[i] = caller->proplines[i]; 535 } 536 } 537 } 538 539 UBool IntlTest::callTest( IntlTest& testToBeCalled, char* par ) 540 { 541 execCount--; // correct a previously assumed test-exec, as this only calls a subtest 542 testToBeCalled.setCaller( this ); 543 strcpy(testToBeCalled.basePath, this->basePath ); 544 UBool result = testToBeCalled.runTest( testPath, par, testToBeCalled.basePath ); 545 strcpy(testToBeCalled.basePath, this->basePath ); // reset it. 546 return result; 547 } 548 549 void IntlTest::setPath( char* pathVal ) 550 { 551 this->testPath = pathVal; 552 } 553 554 UBool IntlTest::setVerbose( UBool verboseVal ) 555 { 556 UBool rval = this->verbose; 557 this->verbose = verboseVal; 558 return rval; 559 } 560 561 UBool IntlTest::setWarnOnMissingData( UBool warn_on_missing_dataVal ) 562 { 563 UBool rval = this->warn_on_missing_data; 564 this->warn_on_missing_data = warn_on_missing_dataVal; 565 return rval; 566 } 567 568 UBool IntlTest::setNoErrMsg( UBool no_err_msgVal ) 569 { 570 UBool rval = this->no_err_msg; 571 this->no_err_msg = no_err_msgVal; 572 return rval; 573 } 574 575 UBool IntlTest::setQuick( UBool quickVal ) 576 { 577 UBool rval = this->quick; 578 this->quick = quickVal; 579 return rval; 580 } 581 582 UBool IntlTest::setLeaks( UBool leaksVal ) 583 { 584 UBool rval = this->leaks; 585 this->leaks = leaksVal; 586 return rval; 587 } 588 589 int32_t IntlTest::setThreadCount( int32_t count ) 590 { 591 int32_t rval = this->threadCount; 592 this->threadCount = count; 593 return rval; 594 } 595 596 int32_t IntlTest::getErrors( void ) 597 { 598 return errorCount; 599 } 600 601 int32_t IntlTest::getDataErrors( void ) 602 { 603 return dataErrorCount; 604 } 605 606 UBool IntlTest::runTest( char* name, char* par, char *baseName ) 607 { 608 UBool rval; 609 char* pos = NULL; 610 611 char* baseNameBuffer = NULL; 612 613 if(baseName == NULL) { 614 baseNameBuffer = (char*)malloc(1024); 615 baseName=baseNameBuffer; 616 strcpy(baseName, "/"); 617 } 618 619 if (name) 620 pos = strchr( name, delim ); // check if name contains path (by looking for '/') 621 if (pos) { 622 testPath = pos+1; // store subpath for calling subtest 623 *pos = 0; // split into two strings 624 }else{ 625 testPath = NULL; 626 } 627 628 if (!name || (name[0] == 0) || (strcmp(name, "*") == 0)) { 629 rval = runTestLoop( NULL, par, baseName ); 630 631 }else if (strcmp( name, "LIST" ) == 0) { 632 this->usage(); 633 rval = TRUE; 634 635 }else{ 636 rval = runTestLoop( name, par, baseName ); 637 } 638 639 if (pos) 640 *pos = delim; // restore original value at pos 641 if(baseNameBuffer!=NULL) { 642 free(baseNameBuffer); 643 } 644 return rval; 645 } 646 647 // call individual tests, to be overriden to call implementations 648 void IntlTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ) 649 { 650 // to be overriden by a method like: 651 /* 652 switch (index) { 653 case 0: name = "First Test"; if (exec) FirstTest( par ); break; 654 case 1: name = "Second Test"; if (exec) SecondTest( par ); break; 655 default: name = ""; break; 656 } 657 */ 658 this->errln("*** runIndexedTest needs to be overriden! ***"); 659 name = ""; exec = exec; index = index; par = par; 660 } 661 662 663 UBool IntlTest::runTestLoop( char* testname, char* par, char *baseName ) 664 { 665 int32_t index = 0; 666 const char* name; 667 UBool run_this_test; 668 int32_t lastErrorCount; 669 UBool rval = FALSE; 670 UBool lastTestFailed; 671 672 if(baseName == NULL) { 673 printf("ERROR: baseName can't be null.\n"); 674 return FALSE; 675 } else { 676 if ((char *)this->basePath != baseName) { 677 strcpy(this->basePath, baseName); 678 } 679 } 680 681 char * saveBaseLoc = baseName+strlen(baseName); 682 683 IntlTest* saveTest = gTest; 684 gTest = this; 685 do { 686 this->runIndexedTest( index, FALSE, name, par ); 687 if (strcmp(name,"skip") == 0) { 688 run_this_test = FALSE; 689 } else { 690 if (!name || (name[0] == 0)) 691 break; 692 if (!testname) { 693 run_this_test = TRUE; 694 }else{ 695 run_this_test = (UBool) (strcmp( name, testname ) == 0); 696 } 697 } 698 if (run_this_test) { 699 lastErrorCount = errorCount; 700 execCount++; 701 char msg[256]; 702 sprintf(msg, "%s {", name); 703 LL_message(msg, TRUE); 704 UDate timeStart = uprv_getRawUTCtime(); 705 strcpy(saveBaseLoc,name); 706 strcat(saveBaseLoc,"/"); 707 708 this->runIndexedTest( index, TRUE, name, par ); 709 710 UDate timeStop = uprv_getRawUTCtime(); 711 rval = TRUE; // at least one test has been called 712 char secs[256]; 713 sprintf(secs, "%f", (timeStop-timeStart)/1000.0); 714 715 716 strcpy(saveBaseLoc,name); 717 718 719 ctest_xml_testcase(baseName, name, secs, (lastErrorCount!=errorCount)?"err":NULL); 720 721 722 saveBaseLoc[0]=0; /* reset path */ 723 724 if (lastErrorCount == errorCount) { 725 sprintf( msg, " } OK: %s ", name ); 726 str_timeDelta(msg+strlen(msg),timeStop-timeStart); 727 lastTestFailed = FALSE; 728 }else{ 729 sprintf(msg, " } ERRORS (%li) in %s", (long)(errorCount-lastErrorCount), name); 730 str_timeDelta(msg+strlen(msg),timeStop-timeStart); 731 732 for(int i=0;i<LL_indentlevel;i++) { 733 errorList += " "; 734 } 735 errorList += name; 736 errorList += "\n"; 737 lastTestFailed = TRUE; 738 } 739 LL_indentlevel -= 3; 740 if (lastTestFailed) { 741 LL_message( "", TRUE); 742 } 743 LL_message( msg, TRUE); 744 if (lastTestFailed) { 745 LL_message( "", TRUE); 746 } 747 LL_indentlevel += 3; 748 } 749 index++; 750 }while(name); 751 752 *saveBaseLoc = 0; 753 754 gTest = saveTest; 755 return rval; 756 } 757 758 759 /** 760 * Adds given string to the log if we are in verbose mode. 761 */ 762 void IntlTest::log( const UnicodeString &message ) 763 { 764 if( verbose ) { 765 LL_message( message, FALSE ); 766 } 767 } 768 769 /** 770 * Adds given string to the log if we are in verbose mode. Adds a new line to 771 * the given message. 772 */ 773 void IntlTest::logln( const UnicodeString &message ) 774 { 775 if( verbose ) { 776 LL_message( message, TRUE ); 777 } 778 } 779 780 void IntlTest::logln( void ) 781 { 782 if( verbose ) { 783 LL_message( "", TRUE ); 784 } 785 } 786 787 /** 788 * Unconditionally adds given string to the log. 789 */ 790 void IntlTest::info( const UnicodeString &message ) 791 { 792 LL_message( message, FALSE ); 793 } 794 795 /** 796 * Unconditionally adds given string to the log. Adds a new line to 797 * the given message. 798 */ 799 void IntlTest::infoln( const UnicodeString &message ) 800 { 801 LL_message( message, TRUE ); 802 } 803 804 void IntlTest::infoln( void ) 805 { 806 LL_message( "", TRUE ); 807 } 808 809 int32_t IntlTest::IncErrorCount( void ) 810 { 811 errorCount++; 812 if (caller) caller->IncErrorCount(); 813 return errorCount; 814 } 815 816 int32_t IntlTest::IncDataErrorCount( void ) 817 { 818 dataErrorCount++; 819 if (caller) caller->IncDataErrorCount(); 820 return dataErrorCount; 821 } 822 823 void IntlTest::err() 824 { 825 IncErrorCount(); 826 } 827 828 void IntlTest::err( const UnicodeString &message ) 829 { 830 IncErrorCount(); 831 if (!no_err_msg) LL_message( message, FALSE ); 832 } 833 834 void IntlTest::errln( const UnicodeString &message ) 835 { 836 IncErrorCount(); 837 if (!no_err_msg) LL_message( message, TRUE ); 838 } 839 840 void IntlTest::dataerr( const UnicodeString &message ) 841 { 842 IncDataErrorCount(); 843 844 if (!warn_on_missing_data) { 845 IncErrorCount(); 846 } 847 848 if (!no_err_msg) LL_message( message, FALSE ); 849 } 850 851 void IntlTest::dataerrln( const UnicodeString &message ) 852 { 853 IncDataErrorCount(); 854 UnicodeString msg; 855 if (!warn_on_missing_data) { 856 IncErrorCount(); 857 msg = message; 858 } else { 859 msg = UnicodeString("[DATA] " + message); 860 } 861 862 if (!no_err_msg) LL_message( msg + " - (Are you missing data?)", TRUE ); 863 } 864 865 void IntlTest::errcheckln(UErrorCode status, const UnicodeString &message ) { 866 if (status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR) { 867 dataerrln(message); 868 } else { 869 errln(message); 870 } 871 } 872 873 /* convenience functions that include sprintf formatting */ 874 void IntlTest::log(const char *fmt, ...) 875 { 876 char buffer[4000]; 877 va_list ap; 878 879 va_start(ap, fmt); 880 /* sprintf it just to make sure that the information is valid */ 881 vsprintf(buffer, fmt, ap); 882 va_end(ap); 883 if( verbose ) { 884 log(UnicodeString(buffer, "")); 885 } 886 } 887 888 void IntlTest::logln(const char *fmt, ...) 889 { 890 char buffer[4000]; 891 va_list ap; 892 893 va_start(ap, fmt); 894 /* sprintf it just to make sure that the information is valid */ 895 vsprintf(buffer, fmt, ap); 896 va_end(ap); 897 if( verbose ) { 898 logln(UnicodeString(buffer, "")); 899 } 900 } 901 902 /* convenience functions that include sprintf formatting */ 903 void IntlTest::info(const char *fmt, ...) 904 { 905 char buffer[4000]; 906 va_list ap; 907 908 va_start(ap, fmt); 909 /* sprintf it just to make sure that the information is valid */ 910 vsprintf(buffer, fmt, ap); 911 va_end(ap); 912 info(UnicodeString(buffer, "")); 913 } 914 915 void IntlTest::infoln(const char *fmt, ...) 916 { 917 char buffer[4000]; 918 va_list ap; 919 920 va_start(ap, fmt); 921 /* sprintf it just to make sure that the information is valid */ 922 vsprintf(buffer, fmt, ap); 923 va_end(ap); 924 infoln(UnicodeString(buffer, "")); 925 } 926 927 void IntlTest::err(const char *fmt, ...) 928 { 929 char buffer[4000]; 930 va_list ap; 931 932 va_start(ap, fmt); 933 vsprintf(buffer, fmt, ap); 934 va_end(ap); 935 err(UnicodeString(buffer, "")); 936 } 937 938 void IntlTest::errln(const char *fmt, ...) 939 { 940 char buffer[4000]; 941 va_list ap; 942 943 va_start(ap, fmt); 944 vsprintf(buffer, fmt, ap); 945 va_end(ap); 946 errln(UnicodeString(buffer, "")); 947 } 948 949 void IntlTest::dataerrln(const char *fmt, ...) 950 { 951 char buffer[4000]; 952 va_list ap; 953 954 va_start(ap, fmt); 955 vsprintf(buffer, fmt, ap); 956 va_end(ap); 957 dataerrln(UnicodeString(buffer, "")); 958 } 959 960 void IntlTest::errcheckln(UErrorCode status, const char *fmt, ...) 961 { 962 char buffer[4000]; 963 va_list ap; 964 965 va_start(ap, fmt); 966 vsprintf(buffer, fmt, ap); 967 va_end(ap); 968 969 if (status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR) { 970 dataerrln(UnicodeString(buffer, "")); 971 } else { 972 errln(UnicodeString(buffer, "")); 973 } 974 } 975 976 void IntlTest::printErrors() 977 { 978 IntlTest::LL_message(errorList, TRUE); 979 } 980 981 void IntlTest::LL_message( UnicodeString message, UBool newline ) 982 { 983 // string that starts with a LineFeed character and continues 984 // with spaces according to the current indentation 985 static const UChar indentUChars[] = { 986 '\n', 987 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 988 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 989 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 990 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 991 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 992 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 993 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 994 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 995 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 996 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 997 }; 998 UnicodeString indent(FALSE, indentUChars, 1 + LL_indentlevel); 999 1000 char buffer[10000]; 1001 int32_t length; 1002 1003 // stream out the indentation string first if necessary 1004 length = indent.extract(1, indent.length(), buffer, sizeof(buffer)); 1005 if (length > 0) { 1006 fwrite(buffer, sizeof(*buffer), length, (FILE *)testoutfp); 1007 } 1008 1009 // replace each LineFeed by the indentation string 1010 message.findAndReplace(UnicodeString((UChar)'\n'), indent); 1011 1012 // stream out the message 1013 length = message.extract(0, message.length(), buffer, sizeof(buffer)); 1014 if (length > 0) { 1015 length = length > 10000 ? 10000 : length; 1016 fwrite(buffer, sizeof(*buffer), length, (FILE *)testoutfp); 1017 } 1018 1019 if (newline) { 1020 char newLine = '\n'; 1021 fwrite(&newLine, sizeof(newLine), 1, (FILE *)testoutfp); 1022 } 1023 1024 // A newline usually flushes the buffer, but 1025 // flush the message just in case of a core dump. 1026 fflush((FILE *)testoutfp); 1027 } 1028 1029 /** 1030 * Print a usage message for this test class. 1031 */ 1032 void IntlTest::usage( void ) 1033 { 1034 UBool save_verbose = setVerbose( TRUE ); 1035 logln("Test names:"); 1036 logln("-----------"); 1037 1038 int32_t index = 0; 1039 const char* name = NULL; 1040 do{ 1041 this->runIndexedTest( index, FALSE, name ); 1042 if (!name) break; 1043 logln(name); 1044 index++; 1045 }while (name && (name[0] != 0)); 1046 setVerbose( save_verbose ); 1047 } 1048 1049 1050 // memory leak reporting software will be able to take advantage of the testsuite 1051 // being run a second time local to a specific method in order to report only actual leaks 1052 UBool 1053 IntlTest::run_phase2( char* name, char* par ) // supports reporting memory leaks 1054 { 1055 UnicodeString* strLeak = new UnicodeString("forced leak"); // for verifying purify filter 1056 strLeak->append(" for verifying purify filter"); 1057 return this->runTest( name, par ); 1058 } 1059 1060 1061 #if UCONFIG_NO_LEGACY_CONVERSION 1062 # define TRY_CNV_1 "iso-8859-1" 1063 # define TRY_CNV_2 "ibm-1208" 1064 #else 1065 # define TRY_CNV_1 "iso-8859-7" 1066 # define TRY_CNV_2 "sjis" 1067 #endif 1068 1069 int 1070 main(int argc, char* argv[]) 1071 { 1072 UBool syntax = FALSE; 1073 UBool all = FALSE; 1074 UBool verbose = FALSE; 1075 UBool no_err_msg = FALSE; 1076 UBool quick = TRUE; 1077 UBool name = FALSE; 1078 UBool leaks = FALSE; 1079 UBool warnOnMissingData = FALSE; 1080 UBool defaultDataFound = FALSE; 1081 int32_t threadCount = 1; 1082 UErrorCode errorCode = U_ZERO_ERROR; 1083 UConverter *cnv = NULL; 1084 const char *warnOrErr = "Failure"; 1085 UDate startTime, endTime; 1086 int32_t diffTime; 1087 const char *props[IntlTest::kMaxProps]; 1088 int32_t nProps = 0; 1089 1090 U_MAIN_INIT_ARGS(argc, argv); 1091 1092 startTime = uprv_getRawUTCtime(); 1093 1094 for (int i = 1; i < argc; ++i) { 1095 if (argv[i][0] == '-') { 1096 const char* str = argv[i] + 1; 1097 if (strcmp("verbose", str) == 0 || 1098 strcmp("v", str) == 0) 1099 verbose = TRUE; 1100 else if (strcmp("noerrormsg", str) == 0 || 1101 strcmp("n", str) == 0) 1102 no_err_msg = TRUE; 1103 else if (strcmp("exhaustive", str) == 0 || 1104 strcmp("e", str) == 0) 1105 quick = FALSE; 1106 else if (strcmp("all", str) == 0 || 1107 strcmp("a", str) == 0) 1108 all = TRUE; 1109 else if (strcmp("leaks", str) == 0 || 1110 strcmp("l", str) == 0) 1111 leaks = TRUE; 1112 else if (strcmp("x", str)==0) { 1113 if(++i>=argc) { 1114 printf("* Error: '-x' option requires an argument. usage: '-x outfile.xml'.\n"); 1115 syntax = TRUE; 1116 } 1117 if(ctest_xml_setFileName(argv[i])) { /* set the name */ 1118 return 1; /* error */ 1119 } 1120 } else if (strcmp("w", str) == 0) { 1121 warnOnMissingData = TRUE; 1122 warnOrErr = "WARNING"; 1123 } 1124 else if (strncmp("threads:", str, 8) == 0) { 1125 threadCount = atoi(str + 8); 1126 } 1127 else if (strncmp("prop:", str, 5) == 0) { 1128 if (nProps < IntlTest::kMaxProps) { 1129 props[nProps] = str + 5; 1130 } 1131 nProps++; 1132 } 1133 else { 1134 syntax = TRUE; 1135 } 1136 }else{ 1137 name = TRUE; 1138 } 1139 } 1140 1141 if (!all && !name) { 1142 all = TRUE; 1143 } else if (all && name) { 1144 syntax = TRUE; 1145 } 1146 1147 if (syntax) { 1148 fprintf(stdout, 1149 "### Syntax:\n" 1150 "### IntlTest [-option1 -option2 ...] [testname1 testname2 ...] \n" 1151 "### \n" 1152 "### Options are: verbose (v), all (a), noerrormsg (n), \n" 1153 "### exhaustive (e), leaks (l), -x xmlfile.xml, prop:<propery>=<value>, \n" 1154 "### threads:<threadCount> (Mulithreading must first be \n" 1155 "### enabled otherwise this will be ignored. \n" 1156 "### The default thread count is 1.),\n" 1157 "### (Specify either -all (shortcut -a) or a test name). \n" 1158 "### -all will run all of the tests.\n" 1159 "### \n" 1160 "### To get a list of the test names type: intltest LIST \n" 1161 "### To run just the utility tests type: intltest utility \n" 1162 "### \n" 1163 "### Test names can be nested using slashes (\"testA/subtest1\") \n" 1164 "### For example to list the utility tests type: intltest utility/LIST \n" 1165 "### To run just the Locale test type: intltest utility/LocaleTest \n" 1166 "### \n" 1167 "### A parameter can be specified for a test by appending '@' and the value \n" 1168 "### to the testname. \n\n"); 1169 return 1; 1170 } 1171 1172 if (nProps > IntlTest::kMaxProps) { 1173 fprintf(stdout, "### Too many properties. Exiting.\n"); 1174 } 1175 1176 UBool all_tests_exist = TRUE; 1177 MajorTestLevel major; 1178 major.setVerbose( verbose ); 1179 major.setNoErrMsg( no_err_msg ); 1180 major.setQuick( quick ); 1181 major.setLeaks( leaks ); 1182 major.setThreadCount( threadCount ); 1183 major.setWarnOnMissingData( warnOnMissingData ); 1184 for (int32_t i = 0; i < nProps; i++) { 1185 major.setProperty(props[i]); 1186 } 1187 1188 1189 fprintf(stdout, "-----------------------------------------------\n"); 1190 fprintf(stdout, " IntlTest (C++) Test Suite for \n"); 1191 fprintf(stdout, " International Components for Unicode %s\n", U_ICU_VERSION); 1192 1193 1194 { 1195 const char *charsetFamily = "Unknown"; 1196 int32_t voidSize = (int32_t)sizeof(void*); 1197 int32_t bits = voidSize * 8; 1198 if(U_CHARSET_FAMILY==U_ASCII_FAMILY) { 1199 charsetFamily="ASCII"; 1200 } else if(U_CHARSET_FAMILY==U_EBCDIC_FAMILY) { 1201 charsetFamily="EBCDIC"; 1202 } 1203 fprintf(stdout, 1204 " Bits: %d, Byte order: %s, Chars: %s\n", 1205 bits, U_IS_BIG_ENDIAN?"Big endian":"Little endian", 1206 charsetFamily); 1207 } 1208 fprintf(stdout, "-----------------------------------------------\n"); 1209 fprintf(stdout, " Options: \n"); 1210 fprintf(stdout, " all (a) : %s\n", (all? "On" : "Off")); 1211 fprintf(stdout, " Verbose (v) : %s\n", (verbose? "On" : "Off")); 1212 fprintf(stdout, " No error messages (n) : %s\n", (no_err_msg? "On" : "Off")); 1213 fprintf(stdout, " Exhaustive (e) : %s\n", (!quick? "On" : "Off")); 1214 fprintf(stdout, " Leaks (l) : %s\n", (leaks? "On" : "Off")); 1215 fprintf(stdout, " Warn on missing data (w) : %s\n", (warnOnMissingData? "On" : "Off")); 1216 #if (ICU_USE_THREADS==0) 1217 fprintf(stdout, " Threads : Disabled\n"); 1218 #else 1219 fprintf(stdout, " Threads : %d\n", threadCount); 1220 #endif 1221 for (int32_t i = 0; i < nProps; i++) { 1222 fprintf(stdout, " Custom property (prop:) : %s\n", props[i]); 1223 } 1224 fprintf(stdout, "-----------------------------------------------\n"); 1225 1226 /* Check whether ICU will initialize without forcing the build data directory into 1227 * the ICU_DATA path. Success here means either the data dll contains data, or that 1228 * this test program was run with ICU_DATA set externally. Failure of this check 1229 * is normal when ICU data is not packaged into a shared library. 1230 * 1231 * Whether or not this test succeeds, we want to cleanup and reinitialize 1232 * with a data path so that data loading from individual files can be tested. 1233 */ 1234 u_init(&errorCode); 1235 if (U_FAILURE(errorCode)) { 1236 fprintf(stderr, 1237 "#### Note: ICU Init without build-specific setDataDirectory() failed.\n"); 1238 defaultDataFound = FALSE; 1239 } 1240 else { 1241 defaultDataFound = TRUE; 1242 } 1243 u_cleanup(); 1244 errorCode = U_ZERO_ERROR; 1245 1246 /* Initialize ICU */ 1247 if (!defaultDataFound) { 1248 IntlTest::setICU_DATA(); // Must set data directory before u_init() is called. 1249 } 1250 u_init(&errorCode); 1251 if (U_FAILURE(errorCode)) { 1252 fprintf(stderr, 1253 "#### ERROR! %s: u_init() failed with status = \"%s\".\n" 1254 "*** Check the ICU_DATA environment variable and \n" 1255 "*** check that the data files are present.\n", argv[0], u_errorName(errorCode)); 1256 if(warnOnMissingData == 0) { 1257 fprintf(stderr, "*** Exiting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n"); 1258 u_cleanup(); 1259 return 1; 1260 } 1261 } 1262 1263 1264 // initial check for the default converter 1265 errorCode = U_ZERO_ERROR; 1266 cnv = ucnv_open(0, &errorCode); 1267 if(cnv != 0) { 1268 // ok 1269 ucnv_close(cnv); 1270 } else { 1271 fprintf(stdout, 1272 "*** %s! The default converter [%s] cannot be opened.\n" 1273 "*** Check the ICU_DATA environment variable and\n" 1274 "*** check that the data files are present.\n", 1275 warnOrErr, ucnv_getDefaultName()); 1276 if(!warnOnMissingData) { 1277 fprintf(stdout, "*** Exiting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n"); 1278 return 1; 1279 } 1280 } 1281 1282 // try more data 1283 cnv = ucnv_open(TRY_CNV_2, &errorCode); 1284 if(cnv != 0) { 1285 // ok 1286 ucnv_close(cnv); 1287 } else { 1288 fprintf(stdout, 1289 "*** %s! The converter for " TRY_CNV_2 " cannot be opened.\n" 1290 "*** Check the ICU_DATA environment variable and \n" 1291 "*** check that the data files are present.\n", warnOrErr); 1292 if(!warnOnMissingData) { 1293 fprintf(stdout, "*** Exiting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n"); 1294 return 1; 1295 } 1296 } 1297 1298 UResourceBundle *rb = ures_open(0, "en", &errorCode); 1299 ures_close(rb); 1300 if(U_FAILURE(errorCode)) { 1301 fprintf(stdout, 1302 "*** %s! The \"en\" locale resource bundle cannot be opened.\n" 1303 "*** Check the ICU_DATA environment variable and \n" 1304 "*** check that the data files are present.\n", warnOrErr); 1305 if(!warnOnMissingData) { 1306 fprintf(stdout, "*** Exiting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n"); 1307 return 1; 1308 } 1309 } 1310 1311 Locale originalLocale; // Save the default locale for comparison later on. 1312 1313 if(ctest_xml_init("intltest")) 1314 return 1; 1315 1316 1317 /* TODO: Add option to call u_cleanup and rerun tests. */ 1318 if (all) { 1319 major.runTest(); 1320 if (leaks) { 1321 major.run_phase2( NULL, NULL ); 1322 } 1323 }else{ 1324 for (int i = 1; i < argc; ++i) { 1325 if (argv[i][0] != '-') { 1326 char* name = argv[i]; 1327 fprintf(stdout, "\n=== Handling test: %s: ===\n", name); 1328 1329 char baseName[1024]; 1330 sprintf(baseName, "/%s/", name); 1331 1332 char* parameter = strchr( name, '@' ); 1333 if (parameter) { 1334 *parameter = 0; 1335 parameter += 1; 1336 } 1337 execCount = 0; 1338 UBool res = major.runTest( name, parameter, baseName ); 1339 if (leaks && res) { 1340 major.run_phase2( name, parameter ); 1341 } 1342 if (!res || (execCount <= 0)) { 1343 fprintf(stdout, "\n---ERROR: Test doesn't exist: %s!\n", name); 1344 all_tests_exist = FALSE; 1345 } 1346 } else if(!strcmp(argv[i],"-x")) { 1347 i++; 1348 } 1349 } 1350 } 1351 1352 1353 #if !UCONFIG_NO_FORMATTING 1354 CalendarTimeZoneTest::cleanup(); 1355 #endif 1356 1357 free(_testDataPath); 1358 _testDataPath = 0; 1359 1360 Locale lastDefaultLocale; 1361 if (originalLocale != lastDefaultLocale) { 1362 major.errln("FAILURE: A test changed the default locale without resetting it."); 1363 } 1364 1365 fprintf(stdout, "\n--------------------------------------\n"); 1366 if (major.getErrors() == 0) { 1367 /* Call it twice to make sure that the defaults were reset. */ 1368 /* Call it before the OK message to verify proper cleanup. */ 1369 u_cleanup(); 1370 u_cleanup(); 1371 1372 fprintf(stdout, "OK: All tests passed without error.\n"); 1373 1374 if (major.getDataErrors() != 0) { 1375 fprintf(stdout, "\t*WARNING* some data-loading errors were ignored by the -w option.\n"); 1376 } 1377 }else{ 1378 fprintf(stdout, "Errors in total: %ld.\n", (long)major.getErrors()); 1379 major.printErrors(); 1380 1381 1382 if (major.getDataErrors() != 0) { 1383 fprintf(stdout, "\t*Note* some errors are data-loading related. If the data used is not the \n" 1384 "\tstock ICU data (i.e some have been added or removed), consider using\n" 1385 "\tthe '-w' option to turn these errors into warnings.\n"); 1386 } 1387 1388 /* Call afterwards to display errors. */ 1389 u_cleanup(); 1390 } 1391 1392 fprintf(stdout, "--------------------------------------\n"); 1393 1394 if (execCount <= 0) { 1395 fprintf(stdout, "***** Not all called tests actually exist! *****\n"); 1396 } 1397 endTime = uprv_getRawUTCtime(); 1398 diffTime = (int32_t)(endTime - startTime); 1399 printf("Elapsed Time: %02d:%02d:%02d.%03d\n", 1400 (int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR), 1401 (int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE), 1402 (int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND), 1403 (int)(diffTime%U_MILLIS_PER_SECOND)); 1404 1405 if(ctest_xml_fini()) 1406 return 1; 1407 1408 return major.getErrors(); 1409 } 1410 1411 const char* IntlTest::loadTestData(UErrorCode& err){ 1412 if( _testDataPath == NULL){ 1413 const char* directory=NULL; 1414 UResourceBundle* test =NULL; 1415 char* tdpath=NULL; 1416 const char* tdrelativepath; 1417 1418 #if defined (U_TOPBUILDDIR) 1419 tdrelativepath = "test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"out"U_FILE_SEP_STRING; 1420 directory = U_TOPBUILDDIR; 1421 #else 1422 tdrelativepath = ".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"out"U_FILE_SEP_STRING; 1423 directory = pathToDataDirectory(); 1424 #endif 1425 1426 tdpath = (char*) malloc(sizeof(char) *(( strlen(directory) * strlen(tdrelativepath)) + 100)); 1427 1428 1429 /* u_getDataDirectory shoul return \source\data ... set the 1430 * directory to ..\source\data\..\test\testdata\out\testdata 1431 */ 1432 strcpy(tdpath, directory); 1433 strcat(tdpath, tdrelativepath); 1434 strcat(tdpath,"testdata"); 1435 1436 test=ures_open(tdpath, "testtypes", &err); 1437 1438 if(U_FAILURE(err)){ 1439 err = U_FILE_ACCESS_ERROR; 1440 it_dataerrln((UnicodeString)"Could not load testtypes.res in testdata bundle with path " + tdpath + (UnicodeString)" - " + u_errorName(err)); 1441 return ""; 1442 } 1443 ures_close(test); 1444 _testDataPath = tdpath; 1445 return _testDataPath; 1446 } 1447 return _testDataPath; 1448 } 1449 1450 const char* IntlTest::getTestDataPath(UErrorCode& err) { 1451 return loadTestData(err); 1452 } 1453 1454 /* Returns the path to icu/source/test/testdata/ */ 1455 const char *IntlTest::getSourceTestData(UErrorCode& /*err*/) { 1456 const char *srcDataDir = NULL; 1457 #ifdef U_TOPSRCDIR 1458 srcDataDir = U_TOPSRCDIR U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING; 1459 #else 1460 srcDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING; 1461 FILE *f = fopen(".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"rbbitst.txt", "r"); 1462 if (f) { 1463 /* We're in icu/source/test/intltest/ */ 1464 fclose(f); 1465 } 1466 else { 1467 /* We're in icu/source/test/intltest/Platform/(Debug|Release) */ 1468 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; 1469 } 1470 #endif 1471 return srcDataDir; 1472 } 1473 1474 const char* IntlTest::fgDataDir = NULL; 1475 1476 /* returns the path to icu/source/data */ 1477 const char * IntlTest::pathToDataDirectory() 1478 { 1479 1480 if(fgDataDir != NULL) { 1481 return fgDataDir; 1482 } 1483 1484 /* U_TOPSRCDIR is set by the makefiles on UNIXes when building cintltst and intltst 1485 // to point to the top of the build hierarchy, which may or 1486 // may not be the same as the source directory, depending on 1487 // the configure options used. At any rate, 1488 // set the data path to the built data from this directory. 1489 // The value is complete with quotes, so it can be used 1490 // as-is as a string constant. 1491 */ 1492 #if defined (U_TOPSRCDIR) 1493 { 1494 fgDataDir = U_TOPSRCDIR U_FILE_SEP_STRING "data" U_FILE_SEP_STRING; 1495 } 1496 #else 1497 1498 /* On Windows, the file name obtained from __FILE__ includes a full path. 1499 * This file is "wherever\icu\source\test\cintltst\cintltst.c" 1500 * Change to "wherever\icu\source\data" 1501 */ 1502 { 1503 static char p[sizeof(__FILE__) + 10]; 1504 char *pBackSlash; 1505 int i; 1506 1507 strcpy(p, __FILE__); 1508 /* We want to back over three '\' chars. */ 1509 /* Only Windows should end up here, so looking for '\' is safe. */ 1510 for (i=1; i<=3; i++) { 1511 pBackSlash = strrchr(p, U_FILE_SEP_CHAR); 1512 if (pBackSlash != NULL) { 1513 *pBackSlash = 0; /* Truncate the string at the '\' */ 1514 } 1515 } 1516 1517 if (pBackSlash != NULL) { 1518 /* We found and truncated three names from the path. 1519 * Now append "source\data" and set the environment 1520 */ 1521 strcpy(pBackSlash, U_FILE_SEP_STRING "data" U_FILE_SEP_STRING ); 1522 fgDataDir = p; 1523 } 1524 else { 1525 /* __FILE__ on MSVC7 does not contain the directory */ 1526 FILE *file = fopen(".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r"); 1527 if (file) { 1528 fclose(file); 1529 fgDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING; 1530 } 1531 else { 1532 fgDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING "data" U_FILE_SEP_STRING; 1533 } 1534 } 1535 } 1536 #endif 1537 1538 return fgDataDir; 1539 1540 } 1541 1542 /* 1543 * This is a variant of cintltst/ccolltst.c:CharsToUChars(). 1544 * It converts an invariant-character string into a UnicodeString, with 1545 * unescaping \u sequences. 1546 */ 1547 UnicodeString CharsToUnicodeString(const char* chars){ 1548 return UnicodeString(chars, -1, US_INV).unescape(); 1549 } 1550 1551 UnicodeString ctou(const char* chars) { 1552 return CharsToUnicodeString(chars); 1553 } 1554 1555 #define RAND_M (714025) 1556 #define RAND_IA (1366) 1557 #define RAND_IC (150889) 1558 1559 static int32_t RAND_SEED; 1560 1561 /** 1562 * Returns a uniform random value x, with 0.0 <= x < 1.0. Use 1563 * with care: Does not return all possible values; returns one of 1564 * 714,025 values, uniformly spaced. However, the period is 1565 * effectively infinite. See: Numerical Recipes, section 7.1. 1566 * 1567 * @param seedp pointer to seed. Set *seedp to any negative value 1568 * to restart the sequence. 1569 */ 1570 float IntlTest::random(int32_t* seedp) { 1571 static int32_t iy, ir[98]; 1572 static UBool first=TRUE; 1573 int32_t j; 1574 if (*seedp < 0 || first) { 1575 first = FALSE; 1576 if ((*seedp=(RAND_IC-(*seedp)) % RAND_M) < 0) *seedp = -(*seedp); 1577 for (j=1;j<=97;++j) { 1578 *seedp=(RAND_IA*(*seedp)+RAND_IC) % RAND_M; 1579 ir[j]=(*seedp); 1580 } 1581 *seedp=(RAND_IA*(*seedp)+RAND_IC) % RAND_M; 1582 iy=(*seedp); 1583 } 1584 j=(int32_t)(1 + 97.0*iy/RAND_M); 1585 U_ASSERT(j>=1 && j<=97); 1586 iy=ir[j]; 1587 *seedp=(RAND_IA*(*seedp)+RAND_IC) % RAND_M; 1588 ir[j]=(*seedp); 1589 return (float) iy/RAND_M; 1590 } 1591 1592 /** 1593 * Convenience method using a global seed. 1594 */ 1595 float IntlTest::random() { 1596 return random(&RAND_SEED); 1597 } 1598 1599 static inline UChar toHex(int32_t i) { 1600 return (UChar)(i + (i < 10 ? 0x30 : (0x41 - 10))); 1601 } 1602 1603 static UnicodeString& escape(const UnicodeString& s, UnicodeString& result) { 1604 for (int32_t i=0; i<s.length(); ++i) { 1605 UChar c = s[i]; 1606 if (c <= (UChar)0x7F) { 1607 result += c; 1608 } else { 1609 result += (UChar)0x5c; 1610 result += (UChar)0x75; 1611 result += toHex((c >> 12) & 0xF); 1612 result += toHex((c >> 8) & 0xF); 1613 result += toHex((c >> 4) & 0xF); 1614 result += toHex( c & 0xF); 1615 } 1616 } 1617 return result; 1618 } 1619 1620 #define VERBOSE_ASSERTIONS 1621 1622 UBool IntlTest::assertTrue(const char* message, UBool condition, UBool quiet, UBool possibleDataError) { 1623 if (!condition) { 1624 if (possibleDataError) { 1625 dataerrln("FAIL: assertTrue() failed: %s", message); 1626 } else { 1627 errln("FAIL: assertTrue() failed: %s", message); 1628 } 1629 } else if (!quiet) { 1630 logln("Ok: %s", message); 1631 } 1632 return condition; 1633 } 1634 1635 UBool IntlTest::assertFalse(const char* message, UBool condition, UBool quiet) { 1636 if (condition) { 1637 errln("FAIL: assertFalse() failed: %s", message); 1638 } else if (!quiet) { 1639 logln("Ok: %s", message); 1640 } 1641 return !condition; 1642 } 1643 1644 UBool IntlTest::assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError) { 1645 if (U_FAILURE(ec)) { 1646 if (possibleDataError) { 1647 dataerrln("FAIL: %s (%s)", message, u_errorName(ec)); 1648 } else { 1649 errcheckln(ec, "FAIL: %s (%s)", message, u_errorName(ec)); 1650 } 1651 1652 return FALSE; 1653 } 1654 return TRUE; 1655 } 1656 1657 UBool IntlTest::assertEquals(const char* message, 1658 const UnicodeString& expected, 1659 const UnicodeString& actual, 1660 UBool possibleDataError) { 1661 if (expected != actual) { 1662 if (possibleDataError) { 1663 dataerrln((UnicodeString)"FAIL: " + message + "; got " + 1664 prettify(actual) + 1665 "; expected " + prettify(expected)); 1666 } else { 1667 errln((UnicodeString)"FAIL: " + message + "; got " + 1668 prettify(actual) + 1669 "; expected " + prettify(expected)); 1670 } 1671 return FALSE; 1672 } 1673 #ifdef VERBOSE_ASSERTIONS 1674 else { 1675 logln((UnicodeString)"Ok: " + message + "; got " + prettify(actual)); 1676 } 1677 #endif 1678 return TRUE; 1679 } 1680 1681 UBool IntlTest::assertEquals(const char* message, 1682 const char* expected, 1683 const char* actual) { 1684 if (uprv_strcmp(expected, actual) != 0) { 1685 errln((UnicodeString)"FAIL: " + message + "; got \"" + 1686 actual + 1687 "\"; expected \"" + expected + "\""); 1688 return FALSE; 1689 } 1690 #ifdef VERBOSE_ASSERTIONS 1691 else { 1692 logln((UnicodeString)"Ok: " + message + "; got \"" + actual + "\""); 1693 } 1694 #endif 1695 return TRUE; 1696 } 1697 1698 #if !UCONFIG_NO_FORMATTING 1699 UBool IntlTest::assertEquals(const char* message, 1700 const Formattable& expected, 1701 const Formattable& actual) { 1702 if (expected != actual) { 1703 errln((UnicodeString)"FAIL: " + message + "; got " + 1704 toString(actual) + 1705 "; expected " + toString(expected)); 1706 return FALSE; 1707 } 1708 #ifdef VERBOSE_ASSERTIONS 1709 else { 1710 logln((UnicodeString)"Ok: " + message + "; got " + toString(actual)); 1711 } 1712 #endif 1713 return TRUE; 1714 } 1715 #endif 1716 1717 static char ASSERT_BUF[256]; 1718 1719 static const char* extractToAssertBuf(const UnicodeString& message) { 1720 UnicodeString buf; 1721 escape(message, buf); 1722 buf.extract(0, 0x7FFFFFFF, ASSERT_BUF, sizeof(ASSERT_BUF)-1, 0); 1723 ASSERT_BUF[sizeof(ASSERT_BUF)-1] = 0; 1724 return ASSERT_BUF; 1725 } 1726 1727 UBool IntlTest::assertTrue(const UnicodeString& message, UBool condition, UBool quiet) { 1728 return assertTrue(extractToAssertBuf(message), condition, quiet); 1729 } 1730 1731 UBool IntlTest::assertFalse(const UnicodeString& message, UBool condition, UBool quiet) { 1732 return assertFalse(extractToAssertBuf(message), condition, quiet); 1733 } 1734 1735 UBool IntlTest::assertSuccess(const UnicodeString& message, UErrorCode ec) { 1736 return assertSuccess(extractToAssertBuf(message), ec); 1737 } 1738 1739 UBool IntlTest::assertEquals(const UnicodeString& message, 1740 const UnicodeString& expected, 1741 const UnicodeString& actual) { 1742 return assertEquals(extractToAssertBuf(message), expected, actual); 1743 } 1744 1745 UBool IntlTest::assertEquals(const UnicodeString& message, 1746 const char* expected, 1747 const char* actual) { 1748 return assertEquals(extractToAssertBuf(message), expected, actual); 1749 } 1750 //-------------------------------------------------------------------- 1751 // Time bomb - allows temporary behavior that expires at a given 1752 // release 1753 //-------------------------------------------------------------------- 1754 1755 UBool IntlTest::isICUVersionAtLeast(const UVersionInfo x) { 1756 UVersionInfo v; 1757 u_getVersion(v); 1758 return (uprv_memcmp(v, x, U_MAX_VERSION_LENGTH) >= 0); 1759 } 1760 1761 #if !UCONFIG_NO_FORMATTING 1762 UBool IntlTest::assertEquals(const UnicodeString& message, 1763 const Formattable& expected, 1764 const Formattable& actual) { 1765 return assertEquals(extractToAssertBuf(message), expected, actual); 1766 } 1767 #endif 1768 1769 void IntlTest::setProperty(const char* propline) { 1770 if (numProps < kMaxProps) { 1771 proplines[numProps] = propline; 1772 } 1773 numProps++; 1774 } 1775 1776 const char* IntlTest::getProperty(const char* prop) { 1777 const char* val = NULL; 1778 for (int32_t i = 0; i < numProps; i++) { 1779 int32_t plen = uprv_strlen(prop); 1780 if ((int32_t)uprv_strlen(proplines[i]) > plen + 1 1781 && proplines[i][plen] == '=' 1782 && uprv_strncmp(proplines[i], prop, plen) == 0) { 1783 val = &(proplines[i][plen+1]); 1784 break; 1785 } 1786 } 1787 return val; 1788 } 1789 1790 /* 1791 * Hey, Emacs, please set the following: 1792 * 1793 * Local Variables: 1794 * indent-tabs-mode: nil 1795 * End: 1796 * 1797 */ 1798
