]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/intltest.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-59117.0.1.tar.gz
[apple/icu.git] / icuSources / test / intltest / intltest.cpp
1 // © 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 */
mirror of ICU