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