OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ******************************************************************************* |
| 3 * Copyright (C) 2014, International Business Machines Corporation and * |
| 4 * others. All Rights Reserved. * |
| 5 ******************************************************************************* |
| 6 * |
| 7 * File UNIFIEDCACHETEST.CPP |
| 8 * |
| 9 ******************************************************************************** |
| 10 */ |
| 11 #include "cstring.h" |
| 12 #include "intltest.h" |
| 13 #include "unifiedcache.h" |
| 14 |
| 15 class UCTItem : public SharedObject { |
| 16 public: |
| 17 char *value; |
| 18 UCTItem(const char *x) : value(NULL) { |
| 19 value = uprv_strdup(x); |
| 20 } |
| 21 virtual ~UCTItem() { |
| 22 uprv_free(value); |
| 23 } |
| 24 }; |
| 25 |
| 26 class UCTItem2 : public SharedObject { |
| 27 }; |
| 28 |
| 29 U_NAMESPACE_BEGIN |
| 30 |
| 31 template<> U_EXPORT |
| 32 const UCTItem *LocaleCacheKey<UCTItem>::createObject( |
| 33 const void * /*unused*/, UErrorCode &status) const { |
| 34 if (uprv_strcmp(fLoc.getName(), "zh") == 0) { |
| 35 status = U_MISSING_RESOURCE_ERROR; |
| 36 return NULL; |
| 37 } |
| 38 if (uprv_strcmp(fLoc.getLanguage(), fLoc.getName()) != 0) { |
| 39 const UCTItem *item = NULL; |
| 40 UnifiedCache::getByLocale(fLoc.getLanguage(), item, status); |
| 41 if (U_FAILURE(status)) { |
| 42 return NULL; |
| 43 } |
| 44 return item; |
| 45 } |
| 46 UCTItem *result = new UCTItem(fLoc.getName()); |
| 47 result->addRef(); |
| 48 return result; |
| 49 } |
| 50 |
| 51 template<> U_EXPORT |
| 52 const UCTItem2 *LocaleCacheKey<UCTItem2>::createObject( |
| 53 const void * /*unused*/, UErrorCode & /*status*/) const { |
| 54 return NULL; |
| 55 } |
| 56 |
| 57 U_NAMESPACE_END |
| 58 |
| 59 |
| 60 class UnifiedCacheTest : public IntlTest { |
| 61 public: |
| 62 UnifiedCacheTest() { |
| 63 } |
| 64 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=
0); |
| 65 private: |
| 66 void TestBasic(); |
| 67 void TestError(); |
| 68 void TestHashEquals(); |
| 69 }; |
| 70 |
| 71 void UnifiedCacheTest::runIndexedTest(int32_t index, UBool exec, const char* &na
me, char* /*par*/) { |
| 72 TESTCASE_AUTO_BEGIN; |
| 73 TESTCASE_AUTO(TestBasic); |
| 74 TESTCASE_AUTO(TestError); |
| 75 TESTCASE_AUTO(TestHashEquals); |
| 76 TESTCASE_AUTO_END; |
| 77 } |
| 78 |
| 79 void UnifiedCacheTest::TestBasic() { |
| 80 UErrorCode status = U_ZERO_ERROR; |
| 81 const UnifiedCache *cache = UnifiedCache::getInstance(status); |
| 82 assertSuccess("", status); |
| 83 cache->flush(); |
| 84 int32_t baseCount = cache->keyCount(); |
| 85 const UCTItem *en = NULL; |
| 86 const UCTItem *enGb = NULL; |
| 87 const UCTItem *enGb2 = NULL; |
| 88 const UCTItem *enUs = NULL; |
| 89 const UCTItem *fr = NULL; |
| 90 const UCTItem *frFr = NULL; |
| 91 cache->get(LocaleCacheKey<UCTItem>("en"), en, status); |
| 92 cache->get(LocaleCacheKey<UCTItem>("en_US"), enUs, status); |
| 93 cache->get(LocaleCacheKey<UCTItem>("en_GB"), enGb, status); |
| 94 cache->get(LocaleCacheKey<UCTItem>("fr_FR"), frFr, status); |
| 95 cache->get(LocaleCacheKey<UCTItem>("fr"), fr, status); |
| 96 cache->get(LocaleCacheKey<UCTItem>("en_GB"), enGb2, status); |
| 97 SharedObject::clearPtr(enGb2); |
| 98 if (enGb != enUs) { |
| 99 errln("Expected en_GB and en_US to resolve to same object."); |
| 100 } |
| 101 if (fr != frFr) { |
| 102 errln("Expected fr and fr_FR to resolve to same object."); |
| 103 } |
| 104 if (enGb == fr) { |
| 105 errln("Expected en_GB and fr to return different objects."); |
| 106 } |
| 107 assertSuccess("", status); |
| 108 // en_US, en_GB, en share one object; fr_FR and fr don't share. |
| 109 // 5 keys in all. |
| 110 assertEquals("", baseCount + 5, cache->keyCount()); |
| 111 SharedObject::clearPtr(enGb); |
| 112 cache->flush(); |
| 113 assertEquals("", baseCount + 5, cache->keyCount()); |
| 114 SharedObject::clearPtr(enUs); |
| 115 SharedObject::clearPtr(en); |
| 116 cache->flush(); |
| 117 // With en_GB and en_US and en cleared there are no more hard references to |
| 118 // the "en" object, so it gets flushed and the keys that refer to it |
| 119 // get removed from the cache. |
| 120 assertEquals("", baseCount + 2, cache->keyCount()); |
| 121 SharedObject::clearPtr(fr); |
| 122 cache->flush(); |
| 123 assertEquals("", baseCount + 2, cache->keyCount()); |
| 124 SharedObject::clearPtr(frFr); |
| 125 cache->flush(); |
| 126 assertEquals("", baseCount + 0, cache->keyCount()); |
| 127 } |
| 128 |
| 129 void UnifiedCacheTest::TestError() { |
| 130 UErrorCode status = U_ZERO_ERROR; |
| 131 const UnifiedCache *cache = UnifiedCache::getInstance(status); |
| 132 assertSuccess("", status); |
| 133 cache->flush(); |
| 134 int32_t baseCount = cache->keyCount(); |
| 135 const UCTItem *zh = NULL; |
| 136 const UCTItem *zhTw = NULL; |
| 137 const UCTItem *zhHk = NULL; |
| 138 |
| 139 status = U_ZERO_ERROR; |
| 140 cache->get(LocaleCacheKey<UCTItem>("zh"), zh, status); |
| 141 if (status != U_MISSING_RESOURCE_ERROR) { |
| 142 errln("Expected U_MISSING_RESOURCE_ERROR"); |
| 143 } |
| 144 status = U_ZERO_ERROR; |
| 145 cache->get(LocaleCacheKey<UCTItem>("zh_TW"), zhTw, status); |
| 146 if (status != U_MISSING_RESOURCE_ERROR) { |
| 147 errln("Expected U_MISSING_RESOURCE_ERROR"); |
| 148 } |
| 149 status = U_ZERO_ERROR; |
| 150 cache->get(LocaleCacheKey<UCTItem>("zh_HK"), zhHk, status); |
| 151 if (status != U_MISSING_RESOURCE_ERROR) { |
| 152 errln("Expected U_MISSING_RESOURCE_ERROR"); |
| 153 } |
| 154 // 3 keys in cache zh, zhTW, zhHk all pointing to error placeholders |
| 155 assertEquals("", baseCount + 3, cache->keyCount()); |
| 156 cache->flush(); |
| 157 // error placeholders have no hard references so they always get flushed. |
| 158 assertEquals("", baseCount + 0, cache->keyCount()); |
| 159 } |
| 160 |
| 161 void UnifiedCacheTest::TestHashEquals() { |
| 162 LocaleCacheKey<UCTItem> key1("en_US"); |
| 163 LocaleCacheKey<UCTItem> key2("en_US"); |
| 164 LocaleCacheKey<UCTItem> diffKey1("en_UT"); |
| 165 LocaleCacheKey<UCTItem2> diffKey2("en_US"); |
| 166 assertTrue("", key1.hashCode() == key2.hashCode()); |
| 167 assertTrue("", key1.hashCode() != diffKey1.hashCode()); |
| 168 assertTrue("", key1.hashCode() != diffKey2.hashCode()); |
| 169 assertTrue("", diffKey1.hashCode() != diffKey2.hashCode()); |
| 170 assertTrue("", key1 == key2); |
| 171 assertTrue("", key1 != diffKey1); |
| 172 assertTrue("", key1 != diffKey2); |
| 173 assertTrue("", diffKey1 != diffKey2); |
| 174 } |
| 175 |
| 176 extern IntlTest *createUnifiedCacheTest() { |
| 177 return new UnifiedCacheTest(); |
| 178 } |
OLD | NEW |