OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ******************************************************************************* |
| 3 * Copyright (C) 2014-2015, International Business Machines Corporation and * |
| 4 * others. All Rights Reserved. * |
| 5 ******************************************************************************* |
| 6 * |
| 7 * File PLURALMAPTEST.CPP |
| 8 * |
| 9 ******************************************************************************** |
| 10 */ |
| 11 #include "unicode/unistr.h" |
| 12 |
| 13 #include "intltest.h" |
| 14 #include "pluralmap.h" |
| 15 |
| 16 class PluralMapForPluralMapTest : public PluralMap<UnicodeString> { |
| 17 public: |
| 18 UBool operator==(const PluralMapForPluralMapTest &other) { |
| 19 return equals(other, strEqual); |
| 20 } |
| 21 private: |
| 22 static UBool strEqual(const UnicodeString &lhs, const UnicodeString &rhs) { |
| 23 return lhs == rhs; |
| 24 } |
| 25 }; |
| 26 |
| 27 class PluralMapTest : public IntlTest { |
| 28 public: |
| 29 PluralMapTest() { |
| 30 } |
| 31 void TestToCategory(); |
| 32 void TestGetCategoryName(); |
| 33 void TestGet(); |
| 34 void TestIterate(); |
| 35 void TestEqual(); |
| 36 void TestCopyAndAssign(); |
| 37 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=
0); |
| 38 void addVariant( |
| 39 PluralMapBase::Category v, |
| 40 const UnicodeString &value, |
| 41 PluralMapForPluralMapTest &map); |
| 42 private: |
| 43 }; |
| 44 |
| 45 void PluralMapTest::runIndexedTest(int32_t index, UBool exec, const char* &name,
char* /*par*/) { |
| 46 TESTCASE_AUTO_BEGIN; |
| 47 TESTCASE_AUTO(TestToCategory); |
| 48 TESTCASE_AUTO(TestGetCategoryName); |
| 49 TESTCASE_AUTO(TestGet); |
| 50 TESTCASE_AUTO(TestIterate); |
| 51 TESTCASE_AUTO(TestEqual); |
| 52 TESTCASE_AUTO(TestCopyAndAssign); |
| 53 TESTCASE_AUTO_END; |
| 54 } |
| 55 |
| 56 void PluralMapTest::TestToCategory() { |
| 57 assertEquals("", PluralMapBase::OTHER, PluralMapBase::toCategory("other")); |
| 58 assertEquals("", PluralMapBase::ZERO, PluralMapBase::toCategory("zero")); |
| 59 assertEquals("", PluralMapBase::ONE, PluralMapBase::toCategory("one")); |
| 60 assertEquals("", PluralMapBase::TWO, PluralMapBase::toCategory("two")); |
| 61 assertEquals("", PluralMapBase::FEW, PluralMapBase::toCategory("few")); |
| 62 assertEquals("", PluralMapBase::MANY, PluralMapBase::toCategory("many")); |
| 63 assertEquals("", PluralMapBase::NONE, PluralMapBase::toCategory("Many")); |
| 64 assertEquals( |
| 65 "", |
| 66 PluralMapBase::FEW, |
| 67 PluralMapBase::toCategory(UnicodeString("few"))); |
| 68 assertEquals( |
| 69 "", |
| 70 PluralMapBase::MANY, |
| 71 PluralMapBase::toCategory(UnicodeString("many"))); |
| 72 assertEquals( |
| 73 "", |
| 74 PluralMapBase::NONE, |
| 75 PluralMapBase::toCategory(UnicodeString("Many"))); |
| 76 } |
| 77 |
| 78 void PluralMapTest::TestGetCategoryName() { |
| 79 assertTrue("", PluralMapBase::getCategoryName(PluralMapBase::NONE) == NULL); |
| 80 assertTrue("", PluralMapBase::getCategoryName(PluralMapBase::CATEGORY_COUNT)
== NULL); |
| 81 assertEquals("", "other", PluralMapBase::getCategoryName(PluralMapBase::OTHE
R)); |
| 82 assertEquals("", "zero", PluralMapBase::getCategoryName(PluralMapBase::ZERO)
); |
| 83 assertEquals("", "one", PluralMapBase::getCategoryName(PluralMapBase::ONE)); |
| 84 assertEquals("", "two", PluralMapBase::getCategoryName(PluralMapBase::TWO)); |
| 85 assertEquals("", "few", PluralMapBase::getCategoryName(PluralMapBase::FEW)); |
| 86 assertEquals("", "many", PluralMapBase::getCategoryName(PluralMapBase::MANY)
); |
| 87 } |
| 88 |
| 89 void PluralMapTest::TestGet() { |
| 90 PluralMapForPluralMapTest map; |
| 91 addVariant(PluralMapBase::OTHER, "pickles", map); |
| 92 addVariant(PluralMapBase::ONE, "pickle", map); |
| 93 addVariant(PluralMapBase::FEW, "picklefew", map); |
| 94 assertEquals("", "pickles", map.get(PluralMapBase::OTHER)); |
| 95 assertEquals("", "pickle", map.get(PluralMapBase::ONE)); |
| 96 assertEquals("", "picklefew", map.get(PluralMapBase::FEW)); |
| 97 assertEquals("", "pickles", map.get(PluralMapBase::MANY)); |
| 98 assertEquals("", "pickles", map.get(PluralMapBase::NONE)); |
| 99 assertEquals("", "pickles", map.get(PluralMapBase::CATEGORY_COUNT)); |
| 100 assertEquals("", "picklefew", map.get("few")); |
| 101 assertEquals("", "pickles", map.get("many")); |
| 102 assertEquals("", "pickles", map.get("somebadform")); |
| 103 assertEquals("", "pickle", map.get(UnicodeString("one"))); |
| 104 assertEquals("", "pickles", map.get(UnicodeString("many"))); |
| 105 assertEquals("", "pickles", map.get(UnicodeString("somebadform"))); |
| 106 assertEquals("", "pickles", map.getOther()); |
| 107 } |
| 108 |
| 109 void PluralMapTest::TestIterate() { |
| 110 PluralMapForPluralMapTest map; |
| 111 addVariant(PluralMapBase::OTHER, "pickles", map); |
| 112 addVariant(PluralMapBase::ONE, "pickle", map); |
| 113 addVariant(PluralMapBase::FEW, "pickleops", map); |
| 114 addVariant(PluralMapBase::FEW, "picklefew", map); |
| 115 PluralMapBase::Category index = PluralMapBase::NONE; |
| 116 const UnicodeString *current = map.next(index); |
| 117 assertEquals("", "pickles", *current); |
| 118 assertEquals("", PluralMapBase::OTHER, index); |
| 119 current = map.next(index); |
| 120 assertEquals("", "pickle", *current); |
| 121 assertEquals("", PluralMapBase::ONE, index); |
| 122 current = map.next(index); |
| 123 assertEquals("", "picklefew", *current); |
| 124 assertEquals("", PluralMapBase::FEW, index); |
| 125 current = map.next(index); |
| 126 assertEquals("", PluralMapBase::CATEGORY_COUNT, index); |
| 127 assertTrue("", current == NULL); |
| 128 |
| 129 PluralMapForPluralMapTest map2; |
| 130 index = PluralMapBase::NONE; |
| 131 current = map2.next(index); |
| 132 assertEquals("", "", *current); |
| 133 assertEquals("", PluralMapBase::OTHER, index); |
| 134 current = map2.next(index); |
| 135 assertEquals("", PluralMapBase::CATEGORY_COUNT, index); |
| 136 assertTrue("", current == NULL); |
| 137 } |
| 138 |
| 139 void PluralMapTest::TestEqual() { |
| 140 PluralMapForPluralMapTest control; |
| 141 addVariant(PluralMapBase::OTHER, "pickles", control); |
| 142 addVariant(PluralMapBase::ONE, "pickle", control); |
| 143 addVariant(PluralMapBase::FEW, "picklefew", control); |
| 144 |
| 145 { |
| 146 PluralMapForPluralMapTest map; |
| 147 addVariant(PluralMapBase::FEW, "picklefew", map); |
| 148 addVariant(PluralMapBase::OTHER, "pickles", map); |
| 149 addVariant(PluralMapBase::ONE, "pickle", map); |
| 150 assertTrue("", control == map); |
| 151 addVariant(PluralMapBase::ONE, "pickl", map); |
| 152 assertFalse("", control == map); |
| 153 } |
| 154 { |
| 155 PluralMapForPluralMapTest map; |
| 156 addVariant(PluralMapBase::MANY, "picklemany", map); |
| 157 addVariant(PluralMapBase::OTHER, "pickles", map); |
| 158 addVariant(PluralMapBase::ONE, "pickle", map); |
| 159 assertFalse("", control == map); |
| 160 } |
| 161 } |
| 162 |
| 163 void PluralMapTest::TestCopyAndAssign() { |
| 164 PluralMapForPluralMapTest control; |
| 165 addVariant(PluralMapBase::OTHER, "pickles", control); |
| 166 addVariant(PluralMapBase::ONE, "pickle", control); |
| 167 addVariant(PluralMapBase::FEW, "picklefew", control); |
| 168 { |
| 169 PluralMapForPluralMapTest *rhs = new PluralMapForPluralMapTest(); |
| 170 if (rhs == NULL) { |
| 171 errln("Memory allocation error."); |
| 172 return; |
| 173 } |
| 174 addVariant(PluralMapBase::OTHER, "pickles", *rhs); |
| 175 addVariant(PluralMapBase::ONE, "pickle", *rhs); |
| 176 addVariant(PluralMapBase::FEW, "picklefew", *rhs); |
| 177 PluralMapForPluralMapTest lhs(*rhs); |
| 178 delete rhs; |
| 179 assertTrue("", lhs == control); |
| 180 } |
| 181 { |
| 182 PluralMapForPluralMapTest *rhs = new PluralMapForPluralMapTest(); |
| 183 if (rhs == NULL) { |
| 184 errln("Memory allocation error."); |
| 185 return; |
| 186 } |
| 187 addVariant(PluralMapBase::OTHER, "pickles", *rhs); |
| 188 addVariant(PluralMapBase::ONE, "pickle", *rhs); |
| 189 addVariant(PluralMapBase::FEW, "picklefew", *rhs); |
| 190 PluralMapForPluralMapTest lhs; |
| 191 addVariant(PluralMapBase::OTHER, "pickles", lhs); |
| 192 addVariant(PluralMapBase::TWO, "pickletwo", lhs); |
| 193 addVariant(PluralMapBase::MANY, "picklemany", lhs); |
| 194 addVariant(PluralMapBase::FEW, "picklefew", lhs); |
| 195 lhs = *rhs; |
| 196 delete rhs; |
| 197 assertTrue("", lhs == control); |
| 198 } |
| 199 |
| 200 } |
| 201 |
| 202 |
| 203 |
| 204 void PluralMapTest::addVariant( |
| 205 PluralMapBase::Category v, |
| 206 const UnicodeString &value, |
| 207 PluralMapForPluralMapTest &map) { |
| 208 UErrorCode status = U_ZERO_ERROR; |
| 209 UnicodeString *current = map.getMutable(v, status); |
| 210 if (!assertSuccess("", status)) { |
| 211 return; |
| 212 } |
| 213 (*current) = value; |
| 214 } |
| 215 |
| 216 extern IntlTest *createPluralMapTest() { |
| 217 return new PluralMapTest(); |
| 218 } |
OLD | NEW |