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