private void AssertOrphanWithCount(CountingMemoryCache <string, int> .Entry entry, int count)
{
Assert.AreNotSame(entry, _cache._cachedEntries.Get(entry.Key), "entry found in the exclusives");
Assert.AreNotSame(entry, _cache._exclusiveEntries.Get(entry.Key), "entry found in the cache");
Assert.IsTrue(entry.Orphan, "entry is not an orphan");
Assert.AreEqual(count, entry.ClientCount, "client count mismatch");
}
public void TestCachingSameKeyTwice()
{
CloseableReference <int> originalRef1 = NewReference(110);
CloseableReference <int> cachedRef1 = _cache.Cache(KEY, originalRef1);
CloseableReference <int> cachedRef2a = _cache.Get(KEY);
CloseableReference <int> cachedRef2b = cachedRef2a.Clone();
CloseableReference <int> cachedRef3 = _cache.Get(KEY);
CountingMemoryCache <string, int> .Entry entry1 = _cache._cachedEntries.Get(KEY);
CloseableReference <int> cachedRef2 = _cache.Cache(KEY, NewReference(120));
CountingMemoryCache <string, int> .Entry entry2 = _cache._cachedEntries.Get(KEY);
Assert.AreNotSame(entry1, entry2);
AssertOrphanWithCount(entry1, 3);
AssertSharedWithCount(KEY, 120, 1);
// Release the orphaned reference only when all clients are gone
originalRef1.Dispose();
cachedRef2b.Dispose();
AssertOrphanWithCount(entry1, 3);
cachedRef2a.Dispose();
AssertOrphanWithCount(entry1, 2);
cachedRef1.Dispose();
AssertOrphanWithCount(entry1, 1);
Assert.AreEqual(0, _releaseCallCount);
cachedRef3.Dispose();
AssertOrphanWithCount(entry1, 0);
Assert.AreEqual(1, _releaseCallCount);
}
private void AssertExclusivelyOwned(string key, int value)
{
Assert.IsTrue(_cache._cachedEntries.Contains(key), "key not found in the cache");
Assert.IsTrue(_cache._exclusiveEntries.Contains(key), "key not found in the exclusives");
CountingMemoryCache <string, int> .Entry entry = _cache._cachedEntries.Get(key);
Assert.IsNotNull(entry, "entry not found in the cache");
Assert.AreEqual(key, entry.Key, "key mismatch");
Assert.AreEqual(value, entry.ValueRef.Get(), "value mismatch");
Assert.AreEqual(0, entry.ClientCount, "client count greater than zero");
Assert.IsFalse(entry.Orphan, "entry is an orphan");
}
/// <summary>
/// Gets the encoded counting memory cache.
/// </summary>
public CountingMemoryCache <ICacheKey, IPooledByteBuffer> GetEncodedCountingMemoryCache()
{
if (_encodedCountingMemoryCache == null)
{
_encodedCountingMemoryCache = EncodedCountingMemoryCacheFactory.Get(
_config.EncodedMemoryCacheParamsSupplier,
_config.MemoryTrimmableRegistry,
GetPlatformBitmapFactory());
}
return(_encodedCountingMemoryCache);
}
/// <summary>
/// Gets the bitmap counting memory cache.
/// </summary>
public CountingMemoryCache <ICacheKey, CloseableImage> GetBitmapCountingMemoryCache()
{
if (_bitmapCountingMemoryCache == null)
{
_bitmapCountingMemoryCache =
BitmapCountingMemoryCacheFactory.Get(
_config.BitmapMemoryCacheParamsSupplier,
_config.MemoryTrimmableRegistry,
GetPlatformBitmapFactory(),
_config.Experiments.IsExternalCreatedBitmapLogEnabled);
}
return(_bitmapCountingMemoryCache);
}
public void Initialize()
{
_releaseCallCount = 0;
_releaseValues = new List <int>();
_releaser = new ResourceReleaserImpl <int>(
v =>
{
++_releaseCallCount;
_releaseValues.Add(v);
});
_onExclusivityChangedCallCount = 0;
_isExclusive = null;
_entryStateObserver = new EntryStateObserverImpl <string>(
(v, b) =>
{
++_onExclusivityChangedCallCount;
_isExclusive = b;
});
_cacheTrimStrategy = new CacheTrimStrategyImpl(v => _trimRatio);
_valueDescriptor = new ValueDescriptorImpl <int>(v => v);
_params = new MemoryCacheParams(
CACHE_MAX_SIZE,
CACHE_MAX_COUNT,
CACHE_EVICTION_QUEUE_MAX_SIZE,
CACHE_EVICTION_QUEUE_MAX_COUNT,
CACHE_ENTRY_MAX_SIZE);
_paramsSupplier = new MockSupplier <MemoryCacheParams>(_params);
_platformBitmapFactory = new MockPlatformBitmapFactory();
_bitmap = new SoftwareBitmap(BitmapPixelFormat.Rgba8, 50, 50);
_bitmapReference = CloseableReference <SoftwareBitmap> .of(
_bitmap, BITMAP_RESOURCE_RELEASER);
_cache = new CountingMemoryCache <string, int>(
_valueDescriptor,
_cacheTrimStrategy,
_paramsSupplier,
_platformBitmapFactory,
true);
}
public void TestRemoveAllMatchingPredicate()
{
CloseableReference <int> originalRef1 = NewReference(110);
CloseableReference <int> valueRef1 = _cache.Cache(KEYS[1], originalRef1);
originalRef1.Dispose();
valueRef1.Dispose();
CloseableReference <int> originalRef2 = NewReference(120);
CloseableReference <int> valueRef2 = _cache.Cache(KEYS[2], originalRef2);
originalRef2.Dispose();
valueRef2.Dispose();
CloseableReference <int> originalRef3 = NewReference(130);
CloseableReference <int> valueRef3 = _cache.Cache(KEYS[3], originalRef3);
originalRef3.Dispose();
CountingMemoryCache <string, int> .Entry entry3 = _cache._cachedEntries.Get(KEYS[3]);
CloseableReference <int> originalRef4 = NewReference(150);
CloseableReference <int> valueRef4 = _cache.Cache(KEYS[4], originalRef4);
originalRef4.Dispose();
int numEvictedEntries = _cache.RemoveAll(
new Predicate <string>(key => key.Equals(KEYS[2]) || key.Equals(KEYS[3])));
Assert.AreEqual(2, numEvictedEntries);
AssertTotalSize(2, 260);
AssertExclusivelyOwnedSize(1, 110);
AssertExclusivelyOwned(KEYS[1], 110);
AssertNotCached(KEYS[2], 120);
AssertOrphanWithCount(entry3, 1);
AssertSharedWithCount(KEYS[4], 150, 1);
Assert.IsTrue(_releaseValues.Contains(120));
Assert.IsFalse(_releaseValues.Contains(130));
valueRef3.Dispose();
Assert.IsTrue(_releaseValues.Contains(130));
}
public void TestClear()
{
CloseableReference <int> originalRef1 = NewReference(110);
CloseableReference <int> cachedRef1 = _cache.Cache(KEYS[1], originalRef1);
originalRef1.Dispose();
CountingMemoryCache <string, int> .Entry entry1 = _cache._cachedEntries.Get(KEYS[1]);
CloseableReference <int> originalRef2 = NewReference(120);
CloseableReference <int> cachedRef2 = _cache.Cache(KEYS[2], originalRef2);
originalRef2.Dispose();
cachedRef2.Dispose();
_cache.Clear();
AssertTotalSize(0, 0);
AssertExclusivelyOwnedSize(0, 0);
AssertOrphanWithCount(entry1, 1);
AssertNotCached(KEYS[2], 120);
Assert.IsTrue(_releaseValues.Contains(120));
cachedRef1.Dispose();
Assert.IsTrue(_releaseValues.Contains(110));
}
/// <summary>
/// Do nothing.
/// </summary>
public void RegisterEncodedMemoryCache <K, V>(CountingMemoryCache <K, V> encodedMemoryCache)
{
}
/// <summary>
/// Do nothing.
/// </summary>
public void RegisterBitmapMemoryCache <K, V>(CountingMemoryCache <K, V> bitmapMemoryCache)
{
}
