Home | History | Annotate | Download | only in intltest 
      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 
     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 
    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 
    111 static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
    112 static void PtrPlusTwo(UErrorCode *code) { *code=(UErrorCode)(*code+2); }
    113 
    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:
    145     MyErrorCode(int32_t &countChecks, int32_t &countDests)
    146         : checks(countChecks), dests(countDests) {}
    147     ~MyErrorCode() {
    148         if(isFailure()) {
    149             ++dests;
    150         }
    151     }
    152 private:
    153     virtual void handleFailure() const {
    154         ++checks;
    155     }
    156     int32_t &checks;
    157     int32_t &dests;
    158 };
    159 
    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:
    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 
    230 static IntlTest *createLocalPointerTest() {
    231     return new LocalPointerTest();
    232 }
    233 
    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.
    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).
    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.
    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.
    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:
    484   EnumSetTest() {}
    485   virtual void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
    486   void TestEnumSet();
    487 };
    488 
    489 static IntlTest *createEnumSetTest() {
    490     return new EnumSetTest();
    491 }
    492 
    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 
    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