source/test/intltest/unifiedcachetest.cpp

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2015, International Business Machines Corporation and         *
   6 * others. All Rights Reserved.                                                *
   7 *******************************************************************************
   8 *
   9 * File UNIFIEDCACHETEST.CPP
  10 *
  11 ********************************************************************************
  12 */
  13 #include "cstring.h"
  14 #include "intltest.h"
  15 #include "unifiedcache.h"
  16 #include "unicode/datefmt.h"
  17
  18 class UCTItem : public SharedObject {
  19   public:
  20     char *value;
  21     UCTItem(const char *x) : value(NULL) {
  22         value = uprv_strdup(x);
  23     }
  24     virtual ~UCTItem() {
  25         uprv_free(value);
  26     }
  27 };
  28
  29 class UCTItem2 : public SharedObject {
  30 };
  31
  32 U_NAMESPACE_BEGIN
  33
  34 template<> U_EXPORT
  35 const UCTItem *LocaleCacheKey<UCTItem>::createObject(
  36         const void *context, UErrorCode &status) const {
  37     const UnifiedCache *cacheContext = (const UnifiedCache *) context;
  38     if (uprv_strcmp(fLoc.getName(), "zh") == 0) {
  39         status = U_MISSING_RESOURCE_ERROR;
  40         return NULL;
  41     }
  42     if (uprv_strcmp(fLoc.getLanguage(), fLoc.getName()) != 0) {
  43         const UCTItem *item = NULL;
  44         if (cacheContext == NULL) {
  45             UnifiedCache::getByLocale(fLoc.getLanguage(), item, status);
  46         } else {
  47             cacheContext->get(LocaleCacheKey<UCTItem>(fLoc.getLanguage()), item, status);
  48         }
  49         if (U_FAILURE(status)) {
  50             return NULL;
  51         }
  52         return item;
  53     }
  54     UCTItem *result = new UCTItem(fLoc.getName());
  55     result->addRef();
  56     return result;
  57 }
  58
  59 template<> U_EXPORT
  60 const UCTItem2 *LocaleCacheKey<UCTItem2>::createObject(
  61         const void * /*unused*/, UErrorCode & /*status*/) const {
  62     return NULL;
  63 }
  64
  65 U_NAMESPACE_END
  66
  67
  68 class UnifiedCacheTest : public IntlTest {
  69 public:
  70     UnifiedCacheTest() {
  71     }
  72     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
  73 private:
  74     void TestEvictionPolicy();
  75     void TestBounded();
  76     void TestBasic();
  77     void TestError();
  78     void TestHashEquals();
  79     void TestEvictionUnderStress();
  80 };
  81
  82 void UnifiedCacheTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
  83   TESTCASE_AUTO_BEGIN;
  84   TESTCASE_AUTO(TestEvictionPolicy);
  85   TESTCASE_AUTO(TestBounded);
  86   TESTCASE_AUTO(TestBasic);
  87   TESTCASE_AUTO(TestError);
  88   TESTCASE_AUTO(TestHashEquals);
  89   TESTCASE_AUTO(TestEvictionUnderStress);
  90   TESTCASE_AUTO_END;
  91 }
  92
  93 void UnifiedCacheTest::TestEvictionUnderStress() {
  94 #if !UCONFIG_NO_FORMATTING
  95     int32_t localeCount;
  96     const Locale *locales = DateFormat::getAvailableLocales(localeCount);
  97     UErrorCode status = U_ZERO_ERROR;
  98     const UnifiedCache *cache = UnifiedCache::getInstance(status);
  99     int64_t evictedCountBefore = cache->autoEvictedCount();
 100     for (int32_t i = 0; i < localeCount; ++i) {
 101         LocalPointer<DateFormat> ptr(DateFormat::createInstanceForSkeleton("yMd", locales[i], status));
 102     }
 103     int64_t evictedCountAfter = cache->autoEvictedCount();
 104     if (evictedCountBefore == evictedCountAfter) {
 105         dataerrln("%s:%d Items should have been evicted from cache",
 106                __FILE__, __LINE__);
 107     }
 108 #endif /* #if !UCONFIG_NO_FORMATTING */
 109 }
 110
 111 void UnifiedCacheTest::TestEvictionPolicy() {
 112     UErrorCode status = U_ZERO_ERROR;
 113
 114     // We have to call this first or else calling the UnifiedCache
 115     // ctor will fail. This is by design to deter clients from using the
 116     // cache API incorrectly by creating their own cache instances.
 117     UnifiedCache::getInstance(status);
 118
 119     // We create our own local UnifiedCache instance to ensure we have
 120     // complete control over it. Real clients should never ever create
 121     // their own cache!
 122     UnifiedCache cache(status);
 123     assertSuccess("", status);
 124
 125     // Don't allow unused entries to exeed more than 100% of in use entries.
 126     cache.setEvictionPolicy(0, 100, status);
 127
 128     static const char *locales[] = {
 129             "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
 130             "11", "12", "13", "14", "15", "16", "17", "18", "19", "20"};
 131
 132     const UCTItem *usedReferences[] = {NULL, NULL, NULL, NULL, NULL};
 133     const UCTItem *unusedReference = NULL;
 134
 135     // Add 5 in-use entries
 136     for (int32_t i = 0; i < UPRV_LENGTHOF(usedReferences); i++) {
 137         cache.get(
 138                 LocaleCacheKey<UCTItem>(locales[i]),
 139                 &cache,
 140                 usedReferences[i],
 141                 status);
 142     }
 143
 144     // Add 10 not in use entries.
 145     for (int32_t i = 0; i < 10; ++i) {
 146         cache.get(
 147                 LocaleCacheKey<UCTItem>(
 148                         locales[i + UPRV_LENGTHOF(usedReferences)]),
 149                 &cache,
 150                 unusedReference,
 151                 status);
 152     }
 153     unusedReference->removeRef();
 154
 155     // unused count not to exeed in use count
 156     assertEquals("", UPRV_LENGTHOF(usedReferences), cache.unusedCount());
 157     assertEquals("", 2*UPRV_LENGTHOF(usedReferences), cache.keyCount());
 158
 159     // Free up those used entries.
 160     for (int32_t i = 0; i < UPRV_LENGTHOF(usedReferences); i++) {
 161         usedReferences[i]->removeRef();
 162     }
 163
 164     // This should free up all cache items
 165     assertEquals("", 0, cache.keyCount());
 166
 167     assertSuccess("", status);
 168 }
 169
 170
 171
 172 void UnifiedCacheTest::TestBounded() {
 173     UErrorCode status = U_ZERO_ERROR;
 174
 175     // We have to call this first or else calling the UnifiedCache
 176     // ctor will fail. This is by design to deter clients from using the
 177     // cache API incorrectly by creating their own cache instances.
 178     UnifiedCache::getInstance(status);
 179
 180     // We create our own local UnifiedCache instance to ensure we have
 181     // complete control over it. Real clients should never ever create
 182     // their own cache!
 183     UnifiedCache cache(status);
 184     assertSuccess("", status);
 185
 186     // Maximum unused count is 3.
 187     cache.setEvictionPolicy(3, 0, status);
 188
 189     // Our cache will hold up to 3 unused key-value pairs
 190     // We test the following invariants:
 191     // 1. unusedCount <= 3
 192     // 2. cache->get(X) always returns the same reference as long as caller
 193     //   already holds references to that same object.
 194
 195     // We first add 5 key-value pairs with two distinct values, "en" and "fr"
 196     // keeping all those references.
 197
 198     const UCTItem *en = NULL;
 199     const UCTItem *enGb = NULL;
 200     const UCTItem *enUs = NULL;
 201     const UCTItem *fr = NULL;
 202     const UCTItem *frFr = NULL;
 203     cache.get(LocaleCacheKey<UCTItem>("en_US"), &cache, enUs, status);
 204     cache.get(LocaleCacheKey<UCTItem>("en"), &cache, en, status);
 205     assertEquals("", 1, cache.unusedCount());
 206     cache.get(LocaleCacheKey<UCTItem>("en_GB"), &cache, enGb, status);
 207     cache.get(LocaleCacheKey<UCTItem>("fr_FR"), &cache, frFr, status);
 208     cache.get(LocaleCacheKey<UCTItem>("fr"), &cache, fr, status);
 209
 210     // Client holds two unique references, "en" and "fr" the other three
 211     // entries are eligible for eviction.
 212     assertEquals("", 3, cache.unusedCount());
 213     assertEquals("", 5, cache.keyCount());
 214
 215     // Exercise cache more but don't hold the references except for
 216     // the last one. At the end of this, we will hold references to one
 217     // additional distinct value, so we will have references to 3 distinct
 218     // values.
 219     const UCTItem *throwAway = NULL;
 220     cache.get(LocaleCacheKey<UCTItem>("zn_AA"), &cache, throwAway, status);
 221     cache.get(LocaleCacheKey<UCTItem>("sr_AA"), &cache, throwAway, status);
 222     cache.get(LocaleCacheKey<UCTItem>("de_AU"), &cache, throwAway, status);
 223
 224     const UCTItem *deAu(throwAway);
 225     deAu->addRef();
 226
 227     // Client holds three unique references, "en", "fr", "de" although we
 228     // could have a total of 8 entries in the cache maxUnusedCount == 3
 229     // so we have only 6 entries.
 230     assertEquals("", 3, cache.unusedCount());
 231     assertEquals("", 6, cache.keyCount());
 232
 233     // For all the references we have, cache must continue to return
 234     // those same references (#2)
 235
 236     cache.get(LocaleCacheKey<UCTItem>("en"), &cache, throwAway, status);
 237     if (throwAway != en) {
 238         errln("Expected en to resolve to the same object.");
 239     }
 240     cache.get(LocaleCacheKey<UCTItem>("en_US"), &cache, throwAway, status);
 241     if (throwAway != enUs) {
 242         errln("Expected enUs to resolve to the same object.");
 243     }
 244     cache.get(LocaleCacheKey<UCTItem>("en_GB"), &cache, throwAway, status);
 245     if (throwAway != enGb) {
 246         errln("Expected enGb to resolve to the same object.");
 247     }
 248     cache.get(LocaleCacheKey<UCTItem>("fr_FR"), &cache, throwAway, status);
 249     if (throwAway != frFr) {
 250         errln("Expected frFr to resolve to the same object.");
 251     }
 252     cache.get(LocaleCacheKey<UCTItem>("fr_FR"), &cache, throwAway, status);
 253     cache.get(LocaleCacheKey<UCTItem>("fr"), &cache, throwAway, status);
 254     if (throwAway != fr) {
 255         errln("Expected fr to resolve to the same object.");
 256     }
 257     cache.get(LocaleCacheKey<UCTItem>("de_AU"), &cache, throwAway, status);
 258     if (throwAway != deAu) {
 259         errln("Expected deAu to resolve to the same object.");
 260     }
 261
 262     assertEquals("", 3, cache.unusedCount());
 263     assertEquals("", 6, cache.keyCount());
 264
 265     // Now we hold a references to two more distinct values. Cache size
 266     // should grow to 8.
 267     const UCTItem *es = NULL;
 268     const UCTItem *ru = NULL;
 269     cache.get(LocaleCacheKey<UCTItem>("es"), &cache, es, status);
 270     cache.get(LocaleCacheKey<UCTItem>("ru"), &cache, ru, status);
 271     assertEquals("", 3, cache.unusedCount());
 272     assertEquals("", 8, cache.keyCount());
 273
 274     // Now release all the references we hold except for
 275     // es, ru, and en
 276     SharedObject::clearPtr(enGb);
 277     SharedObject::clearPtr(enUs);
 278     SharedObject::clearPtr(fr);
 279     SharedObject::clearPtr(frFr);
 280     SharedObject::clearPtr(deAu);
 281     SharedObject::clearPtr(es);
 282     SharedObject::clearPtr(ru);
 283     SharedObject::clearPtr(en);
 284     SharedObject::clearPtr(throwAway);
 285
 286     // Size of cache should magically drop to 3.
 287     assertEquals("", 3, cache.unusedCount());
 288     assertEquals("", 3, cache.keyCount());
 289
 290     // Be sure nothing happens setting the eviction policy in the middle of
 291     // a run.
 292     cache.setEvictionPolicy(3, 0, status);
 293     assertSuccess("", status);
 294
 295 }
 296
 297 void UnifiedCacheTest::TestBasic() {
 298     UErrorCode status = U_ZERO_ERROR;
 299     const UnifiedCache *cache = UnifiedCache::getInstance(status);
 300     assertSuccess("", status);
 301     cache->flush();
 302     int32_t baseCount = cache->keyCount();
 303     const UCTItem *en = NULL;
 304     const UCTItem *enGb = NULL;
 305     const UCTItem *enGb2 = NULL;
 306     const UCTItem *enUs = NULL;
 307     const UCTItem *fr = NULL;
 308     const UCTItem *frFr = NULL;
 309     cache->get(LocaleCacheKey<UCTItem>("en"), en, status);
 310     cache->get(LocaleCacheKey<UCTItem>("en_US"), enUs, status);
 311     cache->get(LocaleCacheKey<UCTItem>("en_GB"), enGb, status);
 312     cache->get(LocaleCacheKey<UCTItem>("fr_FR"), frFr, status);
 313     cache->get(LocaleCacheKey<UCTItem>("fr"), fr, status);
 314     cache->get(LocaleCacheKey<UCTItem>("en_GB"), enGb2, status);
 315     SharedObject::clearPtr(enGb2);
 316     if (enGb != enUs) {
 317         errln("Expected en_GB and en_US to resolve to same object.");
 318     }
 319     if (fr != frFr) {
 320         errln("Expected fr and fr_FR to resolve to same object.");
 321     }
 322     if (enGb == fr) {
 323         errln("Expected en_GB and fr to return different objects.");
 324     }
 325     assertSuccess("", status);
 326     // en_US, en_GB, en share one object; fr_FR and fr don't share.
 327     // 5 keys in all.
 328     assertEquals("", baseCount + 5, cache->keyCount());
 329     SharedObject::clearPtr(enGb);
 330     cache->flush();
 331
 332     // Only 2 unique values in the cache. flushing trims cache down
 333     // to this minimum size.
 334     assertEquals("", baseCount + 2, cache->keyCount());
 335     SharedObject::clearPtr(enUs);
 336     SharedObject::clearPtr(en);
 337     cache->flush();
 338     // With en_GB and en_US and en cleared there are no more hard references to
 339     // the "en" object, so it gets flushed and the keys that refer to it
 340     // get removed from the cache. Now we have just one unique value, fr, in
 341     // the cache
 342     assertEquals("", baseCount + 1, cache->keyCount());
 343     SharedObject::clearPtr(fr);
 344     cache->flush();
 345     assertEquals("", baseCount + 1, cache->keyCount());
 346     SharedObject::clearPtr(frFr);
 347     cache->flush();
 348     assertEquals("", baseCount + 0, cache->keyCount());
 349     assertSuccess("", status);
 350 }
 351
 352 void UnifiedCacheTest::TestError() {
 353     UErrorCode status = U_ZERO_ERROR;
 354     const UnifiedCache *cache = UnifiedCache::getInstance(status);
 355     assertSuccess("", status);
 356     cache->flush();
 357     int32_t baseCount = cache->keyCount();
 358     const UCTItem *zh = NULL;
 359     const UCTItem *zhTw = NULL;
 360     const UCTItem *zhHk = NULL;
 361
 362     status = U_ZERO_ERROR;
 363     cache->get(LocaleCacheKey<UCTItem>("zh"), zh, status);
 364     if (status != U_MISSING_RESOURCE_ERROR) {
 365         errln("Expected U_MISSING_RESOURCE_ERROR");
 366     }
 367     status = U_ZERO_ERROR;
 368     cache->get(LocaleCacheKey<UCTItem>("zh_TW"), zhTw, status);
 369     if (status != U_MISSING_RESOURCE_ERROR) {
 370         errln("Expected U_MISSING_RESOURCE_ERROR");
 371     }
 372     status = U_ZERO_ERROR;
 373     cache->get(LocaleCacheKey<UCTItem>("zh_HK"), zhHk, status);
 374     if (status != U_MISSING_RESOURCE_ERROR) {
 375         errln("Expected U_MISSING_RESOURCE_ERROR");
 376     }
 377     // 3 keys in cache zh, zhTW, zhHk all pointing to error placeholders
 378     assertEquals("", baseCount + 3, cache->keyCount());
 379     cache->flush();
 380     // error placeholders have no hard references so they always get flushed.
 381     assertEquals("", baseCount + 0, cache->keyCount());
 382 }
 383
 384 void UnifiedCacheTest::TestHashEquals() {
 385     LocaleCacheKey<UCTItem> key1("en_US");
 386     LocaleCacheKey<UCTItem> key2("en_US");
 387     LocaleCacheKey<UCTItem> diffKey1("en_UT");
 388     LocaleCacheKey<UCTItem2> diffKey2("en_US");
 389     assertTrue("", key1.hashCode() == key2.hashCode());
 390     assertTrue("", key1.hashCode() != diffKey1.hashCode());
 391     assertTrue("", key1.hashCode() != diffKey2.hashCode());
 392     assertTrue("", diffKey1.hashCode() != diffKey2.hashCode());
 393     assertTrue("", key1 == key2);
 394     assertTrue("", key1 != diffKey1);
 395     assertTrue("", key1 != diffKey2);
 396     assertTrue("", diffKey1 != diffKey2);
 397 }
 398
 399 extern IntlTest *createUnifiedCacheTest() {
 400     return new UnifiedCacheTest();
 401 }