Home | History | Annotate | Download | only in intltest 
      1 /********************************************************************
      2  * COPYRIGHT:
      3  * Copyright (c) 1997-2011, 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 
     36 #define CASE(id, test) case id:                               \
     37                           name = #test;                       \
     38                           if (exec) {                         \
     39                               logln(#test "---"); logln();    \
     40                               test t;                         \
     41                               callTest(t, par);               \
     42                           }                                   \
     43                           break
     44 
     45 void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
     46 {
     47     if (exec) logln("TestSuite Utilities: ");
     48     switch (index) {
     49         CASE(0, MultithreadTest);
     50         CASE(1, StringTest);
     51         CASE(2, UnicodeStringTest);
     52         CASE(3, LocaleTest);
     53         CASE(4, CharIterTest);
     54         CASE(5, UObjectTest);
     55         CASE(6, UnicodeTest);
     56         CASE(7, ResourceBundleTest);
     57         CASE(8, NewResourceBundleTest);
     58         CASE(9, PUtilTest);
     59         CASE(10, UVector32Test);
     60         CASE(11, UVectorTest);
     61         CASE(12, UTextTest);
     62         CASE(13, LocaleAliasTest);
     63         CASE(14, UnicodeSetTest);
     64         CASE(15, ErrorCodeTest);
     65         case 16:
     66             name = "LocalPointerTest";
     67             if (exec) {
     68                 logln("TestSuite LocalPointerTest---"); logln();
     69                 LocalPointer<IntlTest> test(createLocalPointerTest());
     70                 callTest(*test, par);
     71             }
     72             break;
     73         case 17:
     74             name = "BytesTrieTest";
     75             if (exec) {
     76                 logln("TestSuite BytesTrieTest---"); logln();
     77                 LocalPointer<IntlTest> test(createBytesTrieTest());
     78                 callTest(*test, par);
     79             }
     80             break;
     81         case 18:
     82             name = "UCharsTrieTest";
     83             if (exec) {
     84                 logln("TestSuite UCharsTrieTest---"); logln();
     85                 LocalPointer<IntlTest> test(createUCharsTrieTest());
     86                 callTest(*test, par);
     87             }
     88             break;
     89         default: name = ""; break; //needed to end loop
     90     }
     91 }
     92 
     93 void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
     94     if (exec) logln("TestSuite Utilities: ");
     95     switch (index) {
     96         case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break;
     97         case 1: name = "TestSubclass"; if (exec) TestSubclass(); break;
     98         default: name = ""; break; //needed to end loop
     99     }
    100 }
    101 
    102 static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
    103 static void PtrPlusTwo(UErrorCode *code) { *code=(UErrorCode)(*code+2); }
    104 
    105 void ErrorCodeTest::TestErrorCode() {
    106     ErrorCode errorCode;
    107     if(errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure()) {
    108         errln("ErrorCode did not initialize properly");
    109         return;
    110     }
    111     errorCode.assertSuccess();
    112     if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) {
    113         errln("ErrorCode did not format error message string properly");
    114     }
    115     RefPlusOne(errorCode);
    116     if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
    117         errln("ErrorCode did not yield a writable reference");
    118     }
    119     PtrPlusTwo(errorCode);
    120     if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
    121         errln("ErrorCode did not yield a writable pointer");
    122     }
    123     errorCode.set(U_PARSE_ERROR);
    124     if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
    125         errln("ErrorCode.set() failed");
    126     }
    127     if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
    128         !errorCode.isSuccess() || errorCode.isFailure()
    129     ) {
    130         errln("ErrorCode did not reset properly");
    131     }
    132 }
    133 
    134 class MyErrorCode: public ErrorCode {
    135 public:
    136     MyErrorCode(int32_t &countChecks, int32_t &countDests)
    137         : checks(countChecks), dests(countDests) {}
    138     ~MyErrorCode() {
    139         if(isFailure()) {
    140             ++dests;
    141         }
    142     }
    143 private:
    144     virtual void handleFailure() const {
    145         ++checks;
    146     }
    147     int32_t &checks;
    148     int32_t &dests;
    149 };
    150 
    151 void ErrorCodeTest::TestSubclass() {
    152     int32_t countChecks=0;
    153     int32_t countDests=0;
    154     {
    155         MyErrorCode errorCode(countChecks, countDests);
    156         if( errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure() ||
    157             countChecks!=0 || countDests!=0
    158         ) {
    159             errln("ErrorCode did not initialize properly");
    160             return;
    161         }
    162         errorCode.assertSuccess();
    163         if(countChecks!=0) {
    164             errln("ErrorCode.assertSuccess() called handleFailure() despite success");
    165         }
    166         RefPlusOne(errorCode);
    167         if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
    168             errln("ErrorCode did not yield a writable reference");
    169         }
    170         errorCode.assertSuccess();
    171         if(countChecks!=1) {
    172             errln("ErrorCode.assertSuccess() did not handleFailure()");
    173         }
    174         PtrPlusTwo(errorCode);
    175         if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
    176             errln("ErrorCode did not yield a writable pointer");
    177         }
    178         errorCode.assertSuccess();
    179         if(countChecks!=2) {
    180             errln("ErrorCode.assertSuccess() did not handleFailure()");
    181         }
    182         errorCode.set(U_PARSE_ERROR);
    183         if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
    184             errln("ErrorCode.set() failed");
    185         }
    186         if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
    187             !errorCode.isSuccess() || errorCode.isFailure()
    188         ) {
    189             errln("ErrorCode did not reset properly");
    190         }
    191         errorCode.assertSuccess();
    192         if(countChecks!=2) {
    193             errln("ErrorCode.assertSuccess() called handleFailure() despite success");
    194         }
    195     }
    196     if(countDests!=0) {
    197         errln("MyErrorCode destructor detected failure despite success");
    198     }
    199     countChecks=countDests=0;
    200     {
    201         MyErrorCode errorCode(countChecks, countDests);
    202         errorCode.set(U_PARSE_ERROR);
    203     }
    204     if(countDests!=1) {
    205         errln("MyErrorCode destructor failed to detect failure");
    206     }
    207 }
    208 
    209 class LocalPointerTest : public IntlTest {
    210 public:
    211     LocalPointerTest() {}
    212 
    213     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
    214 
    215     void TestLocalPointer();
    216     void TestLocalArray();
    217     void TestLocalXyzPointer();
    218     void TestLocalXyzPointerNull();
    219 };
    220 
    221 static IntlTest *createLocalPointerTest() {
    222     return new LocalPointerTest();
    223 }
    224 
    225 void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
    226     if(exec) {
    227         logln("TestSuite LocalPointerTest: ");
    228     }
    229     switch (index) {
    230         TESTCASE(0, TestLocalPointer);
    231         TESTCASE(1, TestLocalArray);
    232         TESTCASE(2, TestLocalXyzPointer);
    233         TESTCASE(3, TestLocalXyzPointerNull);
    234         default:
    235             name="";
    236             break; // needed to end the loop
    237     }
    238 }
    239 
    240 // Exercise every LocalPointer and LocalPointerBase method.
    241 void LocalPointerTest::TestLocalPointer() {
    242     // constructor
    243     LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
    244     // isNULL(), isValid(), operator==(), operator!=()
    245     if(s.isNull() || !s.isValid() || s==NULL || !(s!=NULL)) {
    246         errln("LocalPointer constructor or NULL test failure");
    247         return;
    248     }
    249     // getAlias(), operator->, operator*
    250     if(s.getAlias()->length()!=2 || s->length()!=2 || (*s).length()!=2) {
    251         errln("LocalPointer access failure");
    252     }
    253     // adoptInstead(), orphan()
    254     s.adoptInstead(new UnicodeString((UChar)0xfffc));
    255     if(s->length()!=1) {
    256         errln("LocalPointer adoptInstead(U+FFFC) failure");
    257     }
    258     UnicodeString *orphan=s.orphan();
    259     if(orphan==NULL || orphan->length()!=1 || s.isValid() || s!=NULL) {
    260         errln("LocalPointer orphan() failure");
    261     }
    262     delete orphan;
    263     // destructor
    264     s.adoptInstead(new UnicodeString());
    265     if(s->length()!=0) {
    266         errln("LocalPointer adoptInstead(empty) failure");
    267     }
    268 }
    269 
    270 // Exercise every LocalArray method (but not LocalPointerBase).
    271 void LocalPointerTest::TestLocalArray() {
    272     // constructor
    273     LocalArray<UnicodeString> a(new UnicodeString[2]);
    274     // operator[]()
    275     a[0].append((UChar)0x61);
    276     a[1].append((UChar32)0x60006);
    277     if(a[0].length()!=1 || a[1].length()!=2) {
    278         errln("LocalArray access failure");
    279     }
    280     // adoptInstead()
    281     a.adoptInstead(new UnicodeString[4]);
    282     a[3].append((UChar)0x62).append((UChar)0x63).reverse();
    283     if(a[3].length()!=2 || a[3][1]!=0x62) {
    284         errln("LocalArray adoptInstead() failure");
    285     }
    286     // destructor
    287 }
    288 
    289 #include "unicode/ucnvsel.h"
    290 #include "unicode/ucal.h"
    291 #include "unicode/udatpg.h"
    292 #include "unicode/uidna.h"
    293 #include "unicode/uldnames.h"
    294 #include "unicode/umsg.h"
    295 #include "unicode/unorm2.h"
    296 #include "unicode/uregex.h"
    297 #include "unicode/utrans.h"
    298 
    299 // Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
    300 void LocalPointerTest::TestLocalXyzPointer() {
    301     IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");
    302 
    303     static const char *const encoding="ISO-8859-1";
    304     LocalUConverterSelectorPointer sel(
    305         ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
    306     if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
    307         return;
    308     }
    309     if(sel.isNull()) {
    310         errln("LocalUConverterSelectorPointer failure");
    311         return;
    312     }
    313 
    314 #if !UCONFIG_NO_FORMATTING
    315     LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
    316     if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
    317         return;
    318     }
    319     if(cal.isNull()) {
    320         errln("LocalUCalendarPointer failure");
    321         return;
    322     }
    323 
    324     LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
    325     if(errorCode.logDataIfFailureAndReset("udatpg_open()")) {
    326         return;
    327     }
    328     if(patgen.isNull()) {
    329         errln("LocalUDateTimePatternGeneratorPointer failure");
    330         return;
    331     }
    332 
    333     LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
    334     if(errorCode.logIfFailureAndReset("uldn_open()")) {
    335         return;
    336     }
    337     if(ldn.isNull()) {
    338         errln("LocalULocaleDisplayNamesPointer failure");
    339         return;
    340     }
    341 
    342     UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
    343     LocalUMessageFormatPointer msg(
    344         umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
    345     if(errorCode.logIfFailureAndReset("umsg_open()")) {
    346         return;
    347     }
    348     if(msg.isNull()) {
    349         errln("LocalUMessageFormatPointer failure");
    350         return;
    351     }
    352 #endif  /* UCONFIG_NO_FORMATTING  */
    353 
    354 #if !UCONFIG_NO_NORMALIZATION
    355     const UNormalizer2 *nfc=unorm2_getInstance(NULL, "nfc", UNORM2_COMPOSE, errorCode);
    356     UnicodeSet emptySet;
    357     LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
    358     if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
    359         return;
    360     }
    361     if(fn2.isNull()) {
    362         errln("LocalUNormalizer2Pointer failure");
    363         return;
    364     }
    365 #endif /* !UCONFIG_NO_NORMALIZATION */
    366 
    367 #if !UCONFIG_NO_IDNA
    368     LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
    369     if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
    370         return;
    371     }
    372     if(idna.isNull()) {
    373         errln("LocalUIDNAPointer failure");
    374         return;
    375     }
    376 #endif  /* !UCONFIG_NO_IDNA */
    377 
    378 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
    379     UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
    380     LocalURegularExpressionPointer regex(
    381         uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
    382     if(errorCode.logIfFailureAndReset("uregex_open()")) {
    383         return;
    384     }
    385     if(regex.isNull()) {
    386         errln("LocalURegularExpressionPointer failure");
    387         return;
    388     }
    389 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
    390 
    391 #if !UCONFIG_NO_TRANSLITERATION
    392     UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
    393     LocalUTransliteratorPointer trans(
    394         utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
    395     if(errorCode.logIfFailureAndReset("utrans_open()")) {
    396         return;
    397     }
    398     if(trans.isNull()) {
    399         errln("LocalUTransliteratorPointer failure");
    400         return;
    401     }
    402 #endif /* !UCONFIG_NO_TRANSLITERATION */
    403 
    404     // destructors
    405 }
    406 
    407 // Try LocalXyzPointer types with NULL pointers.
    408 void LocalPointerTest::TestLocalXyzPointerNull() {
    409     {
    410         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer");
    411         static const char *const encoding="ISO-8859-1";
    412         LocalUConverterSelectorPointer null;
    413         LocalUConverterSelectorPointer sel(
    414             ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
    415         sel.adoptInstead(NULL);
    416     }
    417 #if !UCONFIG_NO_FORMATTING
    418     {
    419         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer");
    420         LocalUCalendarPointer null;
    421         LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
    422         if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
    423             cal.adoptInstead(NULL);
    424         }
    425     }
    426     {
    427         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer");
    428         LocalUDateTimePatternGeneratorPointer null;
    429         LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
    430         patgen.adoptInstead(NULL);
    431     }
    432     {
    433         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer");
    434         UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
    435         LocalUMessageFormatPointer null;
    436         LocalUMessageFormatPointer msg(
    437             umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
    438         msg.adoptInstead(NULL);
    439     }
    440 #endif /* !UCONFIG_NO_FORMATTING */
    441 
    442 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
    443     {
    444         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer");
    445         UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
    446         LocalURegularExpressionPointer null;
    447         LocalURegularExpressionPointer regex(
    448             uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
    449         if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
    450             regex.adoptInstead(NULL);
    451         }
    452     }
    453 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
    454 
    455 #if !UCONFIG_NO_TRANSLITERATION
    456     {
    457         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer");
    458         UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
    459         LocalUTransliteratorPointer null;
    460         LocalUTransliteratorPointer trans(
    461             utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
    462         if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
    463             trans.adoptInstead(NULL);
    464         }
    465     }
    466 #endif /* !UCONFIG_NO_TRANSLITERATION */
    467 
    468 }
    469