1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2012, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6
7
8 /**
9 * IntlTestUtilities is the medium level test class for everything in the directory "utility".
10 */
11
12 #include "unicode/utypes.h"
13 #include "unicode/errorcode.h"
14 #include "unicode/localpointer.h"
15 #include "itutil.h"
16 #include "strtest.h"
17 #include "loctest.h"
18 #include "citrtest.h"
19 #include "ustrtest.h"
20 #include "ucdtest.h"
21 #include "restest.h"
22 #include "restsnew.h"
23 #include "tsmthred.h"
24 #include "tsputil.h"
25 #include "uobjtest.h"
26 #include "utxttest.h"
27 #include "v32test.h"
28 #include "uvectest.h"
29 #include "aliastst.h"
30 #include "usettest.h"
31
32 extern IntlTest *createBytesTrieTest();
33 static IntlTest *createLocalPointerTest();
34 extern IntlTest *createUCharsTrieTest();
35 static IntlTest *createEnumSetTest();
36
37 #define CASE(id, test) case id: \
38 name = #test; \
39 if (exec) { \
40 logln(#test "---"); logln(); \
41 test t; \
42 callTest(t, par); \
43 } \
44 break
45
runIndexedTest(int32_t index,UBool exec,const char * & name,char * par)46 void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
47 {
48 if (exec) logln("TestSuite Utilities: ");
49 switch (index) {
50 CASE(0, MultithreadTest);
51 CASE(1, StringTest);
52 CASE(2, UnicodeStringTest);
53 CASE(3, LocaleTest);
54 CASE(4, CharIterTest);
55 CASE(5, UObjectTest);
56 CASE(6, UnicodeTest);
57 CASE(7, ResourceBundleTest);
58 CASE(8, NewResourceBundleTest);
59 CASE(9, PUtilTest);
60 CASE(10, UVector32Test);
61 CASE(11, UVectorTest);
62 CASE(12, UTextTest);
63 CASE(13, LocaleAliasTest);
64 CASE(14, UnicodeSetTest);
65 CASE(15, ErrorCodeTest);
66 case 16:
67 name = "LocalPointerTest";
68 if (exec) {
69 logln("TestSuite LocalPointerTest---"); logln();
70 LocalPointer<IntlTest> test(createLocalPointerTest());
71 callTest(*test, par);
72 }
73 break;
74 case 17:
75 name = "BytesTrieTest";
76 if (exec) {
77 logln("TestSuite BytesTrieTest---"); logln();
78 LocalPointer<IntlTest> test(createBytesTrieTest());
79 callTest(*test, par);
80 }
81 break;
82 case 18:
83 name = "UCharsTrieTest";
84 if (exec) {
85 logln("TestSuite UCharsTrieTest---"); logln();
86 LocalPointer<IntlTest> test(createUCharsTrieTest());
87 callTest(*test, par);
88 }
89 break;
90 case 19:
91 name = "EnumSetTest";
92 if (exec) {
93 logln("TestSuite EnumSetTest---"); logln();
94 LocalPointer<IntlTest> test(createEnumSetTest());
95 callTest(*test, par);
96 }
97 break;
98 default: name = ""; break; //needed to end loop
99 }
100 }
101
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)102 void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
103 if (exec) logln("TestSuite Utilities: ");
104 switch (index) {
105 case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break;
106 case 1: name = "TestSubclass"; if (exec) TestSubclass(); break;
107 default: name = ""; break; //needed to end loop
108 }
109 }
110
RefPlusOne(UErrorCode & code)111 static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
PtrPlusTwo(UErrorCode * code)112 static void PtrPlusTwo(UErrorCode *code) { *code=(UErrorCode)(*code+2); }
113
TestErrorCode()114 void ErrorCodeTest::TestErrorCode() {
115 ErrorCode errorCode;
116 if(errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure()) {
117 errln("ErrorCode did not initialize properly");
118 return;
119 }
120 errorCode.assertSuccess();
121 if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) {
122 errln("ErrorCode did not format error message string properly");
123 }
124 RefPlusOne(errorCode);
125 if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
126 errln("ErrorCode did not yield a writable reference");
127 }
128 PtrPlusTwo(errorCode);
129 if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
130 errln("ErrorCode did not yield a writable pointer");
131 }
132 errorCode.set(U_PARSE_ERROR);
133 if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
134 errln("ErrorCode.set() failed");
135 }
136 if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
137 !errorCode.isSuccess() || errorCode.isFailure()
138 ) {
139 errln("ErrorCode did not reset properly");
140 }
141 }
142
143 class MyErrorCode: public ErrorCode {
144 public:
MyErrorCode(int32_t & countChecks,int32_t & countDests)145 MyErrorCode(int32_t &countChecks, int32_t &countDests)
146 : checks(countChecks), dests(countDests) {}
~MyErrorCode()147 ~MyErrorCode() {
148 if(isFailure()) {
149 ++dests;
150 }
151 }
152 private:
handleFailure() const153 virtual void handleFailure() const {
154 ++checks;
155 }
156 int32_t &checks;
157 int32_t &dests;
158 };
159
TestSubclass()160 void ErrorCodeTest::TestSubclass() {
161 int32_t countChecks=0;
162 int32_t countDests=0;
163 {
164 MyErrorCode errorCode(countChecks, countDests);
165 if( errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure() ||
166 countChecks!=0 || countDests!=0
167 ) {
168 errln("ErrorCode did not initialize properly");
169 return;
170 }
171 errorCode.assertSuccess();
172 if(countChecks!=0) {
173 errln("ErrorCode.assertSuccess() called handleFailure() despite success");
174 }
175 RefPlusOne(errorCode);
176 if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
177 errln("ErrorCode did not yield a writable reference");
178 }
179 errorCode.assertSuccess();
180 if(countChecks!=1) {
181 errln("ErrorCode.assertSuccess() did not handleFailure()");
182 }
183 PtrPlusTwo(errorCode);
184 if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
185 errln("ErrorCode did not yield a writable pointer");
186 }
187 errorCode.assertSuccess();
188 if(countChecks!=2) {
189 errln("ErrorCode.assertSuccess() did not handleFailure()");
190 }
191 errorCode.set(U_PARSE_ERROR);
192 if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
193 errln("ErrorCode.set() failed");
194 }
195 if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
196 !errorCode.isSuccess() || errorCode.isFailure()
197 ) {
198 errln("ErrorCode did not reset properly");
199 }
200 errorCode.assertSuccess();
201 if(countChecks!=2) {
202 errln("ErrorCode.assertSuccess() called handleFailure() despite success");
203 }
204 }
205 if(countDests!=0) {
206 errln("MyErrorCode destructor detected failure despite success");
207 }
208 countChecks=countDests=0;
209 {
210 MyErrorCode errorCode(countChecks, countDests);
211 errorCode.set(U_PARSE_ERROR);
212 }
213 if(countDests!=1) {
214 errln("MyErrorCode destructor failed to detect failure");
215 }
216 }
217
218 class LocalPointerTest : public IntlTest {
219 public:
LocalPointerTest()220 LocalPointerTest() {}
221
222 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
223
224 void TestLocalPointer();
225 void TestLocalArray();
226 void TestLocalXyzPointer();
227 void TestLocalXyzPointerNull();
228 };
229
createLocalPointerTest()230 static IntlTest *createLocalPointerTest() {
231 return new LocalPointerTest();
232 }
233
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)234 void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
235 if(exec) {
236 logln("TestSuite LocalPointerTest: ");
237 }
238 switch (index) {
239 TESTCASE(0, TestLocalPointer);
240 TESTCASE(1, TestLocalArray);
241 TESTCASE(2, TestLocalXyzPointer);
242 TESTCASE(3, TestLocalXyzPointerNull);
243 default:
244 name="";
245 break; // needed to end the loop
246 }
247 }
248
249 // Exercise every LocalPointer and LocalPointerBase method.
TestLocalPointer()250 void LocalPointerTest::TestLocalPointer() {
251 // constructor
252 LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
253 // isNULL(), isValid(), operator==(), operator!=()
254 if(s.isNull() || !s.isValid() || s==NULL || !(s!=NULL)) {
255 errln("LocalPointer constructor or NULL test failure");
256 return;
257 }
258 // getAlias(), operator->, operator*
259 if(s.getAlias()->length()!=2 || s->length()!=2 || (*s).length()!=2) {
260 errln("LocalPointer access failure");
261 }
262 // adoptInstead(), orphan()
263 s.adoptInstead(new UnicodeString((UChar)0xfffc));
264 if(s->length()!=1) {
265 errln("LocalPointer adoptInstead(U+FFFC) failure");
266 }
267 UnicodeString *orphan=s.orphan();
268 if(orphan==NULL || orphan->length()!=1 || s.isValid() || s!=NULL) {
269 errln("LocalPointer orphan() failure");
270 }
271 delete orphan;
272 // destructor
273 s.adoptInstead(new UnicodeString());
274 if(s->length()!=0) {
275 errln("LocalPointer adoptInstead(empty) failure");
276 }
277 }
278
279 // Exercise every LocalArray method (but not LocalPointerBase).
TestLocalArray()280 void LocalPointerTest::TestLocalArray() {
281 // constructor
282 LocalArray<UnicodeString> a(new UnicodeString[2]);
283 // operator[]()
284 a[0].append((UChar)0x61);
285 a[1].append((UChar32)0x60006);
286 if(a[0].length()!=1 || a[1].length()!=2) {
287 errln("LocalArray access failure");
288 }
289 // adoptInstead()
290 a.adoptInstead(new UnicodeString[4]);
291 a[3].append((UChar)0x62).append((UChar)0x63).reverse();
292 if(a[3].length()!=2 || a[3][1]!=0x62) {
293 errln("LocalArray adoptInstead() failure");
294 }
295 // destructor
296 }
297
298 #include "unicode/ucnvsel.h"
299 #include "unicode/ucal.h"
300 #include "unicode/udatpg.h"
301 #include "unicode/uidna.h"
302 #include "unicode/uldnames.h"
303 #include "unicode/umsg.h"
304 #include "unicode/unorm2.h"
305 #include "unicode/uregex.h"
306 #include "unicode/utrans.h"
307
308 // Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
TestLocalXyzPointer()309 void LocalPointerTest::TestLocalXyzPointer() {
310 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");
311
312 static const char *const encoding="ISO-8859-1";
313 LocalUConverterSelectorPointer sel(
314 ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
315 if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
316 return;
317 }
318 if(sel.isNull()) {
319 errln("LocalUConverterSelectorPointer failure");
320 return;
321 }
322
323 #if !UCONFIG_NO_FORMATTING
324 LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
325 if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
326 return;
327 }
328 if(cal.isNull()) {
329 errln("LocalUCalendarPointer failure");
330 return;
331 }
332
333 LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
334 if(errorCode.logDataIfFailureAndReset("udatpg_open()")) {
335 return;
336 }
337 if(patgen.isNull()) {
338 errln("LocalUDateTimePatternGeneratorPointer failure");
339 return;
340 }
341
342 LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
343 if(errorCode.logIfFailureAndReset("uldn_open()")) {
344 return;
345 }
346 if(ldn.isNull()) {
347 errln("LocalULocaleDisplayNamesPointer failure");
348 return;
349 }
350
351 UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
352 LocalUMessageFormatPointer msg(
353 umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
354 if(errorCode.logIfFailureAndReset("umsg_open()")) {
355 return;
356 }
357 if(msg.isNull()) {
358 errln("LocalUMessageFormatPointer failure");
359 return;
360 }
361 #endif /* UCONFIG_NO_FORMATTING */
362
363 #if !UCONFIG_NO_NORMALIZATION
364 const UNormalizer2 *nfc=unorm2_getNFCInstance(errorCode);
365 UnicodeSet emptySet;
366 LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
367 if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
368 return;
369 }
370 if(fn2.isNull()) {
371 errln("LocalUNormalizer2Pointer failure");
372 return;
373 }
374 #endif /* !UCONFIG_NO_NORMALIZATION */
375
376 #if !UCONFIG_NO_IDNA
377 LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
378 if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
379 return;
380 }
381 if(idna.isNull()) {
382 errln("LocalUIDNAPointer failure");
383 return;
384 }
385 #endif /* !UCONFIG_NO_IDNA */
386
387 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
388 UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
389 LocalURegularExpressionPointer regex(
390 uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
391 if(errorCode.logIfFailureAndReset("uregex_open()")) {
392 return;
393 }
394 if(regex.isNull()) {
395 errln("LocalURegularExpressionPointer failure");
396 return;
397 }
398 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
399
400 #if !UCONFIG_NO_TRANSLITERATION
401 UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
402 LocalUTransliteratorPointer trans(
403 utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
404 if(errorCode.logIfFailureAndReset("utrans_open()")) {
405 return;
406 }
407 if(trans.isNull()) {
408 errln("LocalUTransliteratorPointer failure");
409 return;
410 }
411 #endif /* !UCONFIG_NO_TRANSLITERATION */
412
413 // destructors
414 }
415
416 // Try LocalXyzPointer types with NULL pointers.
TestLocalXyzPointerNull()417 void LocalPointerTest::TestLocalXyzPointerNull() {
418 {
419 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer");
420 static const char *const encoding="ISO-8859-1";
421 LocalUConverterSelectorPointer null;
422 LocalUConverterSelectorPointer sel(
423 ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
424 sel.adoptInstead(NULL);
425 }
426 #if !UCONFIG_NO_FORMATTING
427 {
428 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer");
429 LocalUCalendarPointer null;
430 LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
431 if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
432 cal.adoptInstead(NULL);
433 }
434 }
435 {
436 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer");
437 LocalUDateTimePatternGeneratorPointer null;
438 LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
439 patgen.adoptInstead(NULL);
440 }
441 {
442 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer");
443 UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
444 LocalUMessageFormatPointer null;
445 LocalUMessageFormatPointer msg(
446 umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
447 msg.adoptInstead(NULL);
448 }
449 #endif /* !UCONFIG_NO_FORMATTING */
450
451 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
452 {
453 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer");
454 UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
455 LocalURegularExpressionPointer null;
456 LocalURegularExpressionPointer regex(
457 uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
458 if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
459 regex.adoptInstead(NULL);
460 }
461 }
462 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
463
464 #if !UCONFIG_NO_TRANSLITERATION
465 {
466 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer");
467 UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
468 LocalUTransliteratorPointer null;
469 LocalUTransliteratorPointer trans(
470 utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
471 if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
472 trans.adoptInstead(NULL);
473 }
474 }
475 #endif /* !UCONFIG_NO_TRANSLITERATION */
476
477 }
478
479 /** EnumSet test **/
480 #include "unicode/enumset.h"
481
482 class EnumSetTest : public IntlTest {
483 public:
EnumSetTest()484 EnumSetTest() {}
485 virtual void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
486 void TestEnumSet();
487 };
488
createEnumSetTest()489 static IntlTest *createEnumSetTest() {
490 return new EnumSetTest();
491 }
492
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)493 void EnumSetTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
494 TESTCASE_AUTO_BEGIN;
495 TESTCASE_AUTO(TestEnumSet);
496 TESTCASE_AUTO_END;
497 }
498 enum myEnum {
499 MAX_NONBOOLEAN=-1,
500 THING1,
501 THING2,
502 THING3,
503 LIMIT_BOOLEAN
504 };
505
TestEnumSet()506 void EnumSetTest::TestEnumSet() {
507 EnumSet<myEnum,
508 MAX_NONBOOLEAN+1,
509 LIMIT_BOOLEAN>
510 flags;
511
512 logln("Enum is from [%d..%d]\n", MAX_NONBOOLEAN+1,
513 LIMIT_BOOLEAN);
514
515 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
516 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
517 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
518
519 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
520 logln("Value now: %d\n", flags.getAll());
521 flags.clear();
522 logln("clear -Value now: %d\n", flags.getAll());
523 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
524 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
525 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
526 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
527 flags.add(THING1);
528 logln("set THING1 -Value now: %d\n", flags.getAll());
529 TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
530 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
531 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
532 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
533 flags.add(THING3);
534 logln("set THING3 -Value now: %d\n", flags.getAll());
535 TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
536 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
537 TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
538 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
539 flags.remove(THING2);
540 TEST_ASSERT_TRUE(flags.get(THING1) == TRUE);
541 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
542 TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
543 logln("remove THING2 -Value now: %d\n", flags.getAll());
544 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
545 flags.remove(THING1);
546 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
547 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
548 TEST_ASSERT_TRUE(flags.get(THING3) == TRUE);
549 logln("remove THING1 -Value now: %d\n", flags.getAll());
550 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
551
552 flags.clear();
553 logln("clear -Value now: %d\n", flags.getAll());
554 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3));
555 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE);
556 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE);
557 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE);
558 }
559