Exemplo n.º 1
0
        public void TestCacheTestCacheDictionariesNumber()
        {
            var mainStore = new MainStore <int, int>();
            var cache     = new Cache <int, int>(mainStore);

            Assert.AreEqual((uint)4, cache.NWay);
            Assert.AreEqual((uint)128, cache.TotalCacheEntries);
            Assert.AreEqual((uint)32, cache.CacheSets);
        }
Exemplo n.º 2
0
        public void TestMainStoreDelete()
        {
            var mainStore = new MainStore <int, int>();

            mainStore.PutValue(1, 2);
            mainStore.PutValue(2, 2);

            Assert.AreEqual(true, mainStore.DeleteValue(1));
            Assert.AreEqual(1, mainStore.Count());

            Assert.AreEqual(false, mainStore.DeleteValue(3));
        }
Exemplo n.º 3
0
        public void TestMainStoreAdd()
        {
            var mainStore = new MainStore <int, int>();

            mainStore.PutValue(1, 1);
            mainStore.PutValue(1, 2);

            Assert.AreEqual(1, mainStore.Count());

            mainStore.PutValue(2, 1);
            Assert.AreEqual(2, mainStore.Count());
        }
Exemplo n.º 4
0
        public void TestCacheListenerTesting()
        {
            var  mainStore    = new MainStore <int, int>();
            uint nWay         = 2;
            uint cacheEntries = 4;
            var  cache        = new Cache <int, int>(mainStore, nWay, cacheEntries);

            List <EventArgs> missEvents = new List <EventArgs>();

            cache.CacheMissListener += delegate(object sender, EventArgs e)
            {
                missEvents.Add(e);
            };

            List <InvalidationSource> invalidationEvents = new List <InvalidationSource>();

            cache.CacheEvictionListener += delegate(object sender, InvalidationEventArgs e)
            {
                invalidationEvents.Add(e.Source);
            };

            Assert.AreEqual((uint)2, cache.CacheSets);

            mainStore.PutValue(1, 1);
            mainStore.PutValue(2, 2);
            mainStore.PutValue(3, 3);
            mainStore.PutValue(4, 4);
            mainStore.PutValue(5, 5);

            cache.PutValue(1, 1);
            cache.PutValue(2, 2);
            cache.PutValue(3, 3);
            cache.PutValue(4, 4);

            // not in the cache
            int value;

            value = cache.TryGetValue(5);
            Assert.AreEqual(5, value);
            //value 5 isn't in the cache this prompts us to go to the store and reinsert it.
            Assert.AreEqual(InvalidationSource.Eviction, invalidationEvents[0]);

            Assert.AreEqual(1, missEvents.Count);
            cache.PutValue(7, 7);
            Assert.AreEqual(InvalidationSource.Eviction, invalidationEvents[1]);

            cache.DeleteValue(2);
            Assert.AreEqual(InvalidationSource.User, invalidationEvents[2]);

            cache.PutValue(4, 16);
            Assert.AreEqual(InvalidationSource.Replacement, invalidationEvents[3]);
        }
Exemplo n.º 5
0
        public void TestMainStoreGet()
        {
            var mainStore = new MainStore <int, int>();

            mainStore.PutValue(1, 2);

            Assert.AreEqual(2, mainStore.GetValue(1));

            mainStore.PutValue(2, 1);
            Assert.AreNotEqual(2, mainStore.GetValue(2));

            var n = mainStore.GetValue(3);
        }
Exemplo n.º 6
0
        public void TestCacheCheckExceptions()
        {
            var  mainStore = new MainStore <int, int>();
            uint nWay;
            uint cacheEntries;

            var ex = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(null));

            StringAssert.Contains(ex.Message, "Main data store isn't specified!");

            nWay         = 6;
            cacheEntries = 128;
            ex           = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(mainStore, nWay, cacheEntries));
            StringAssert.Contains(ex.Message, "N-Way should be a power of two!");

            nWay         = 256;
            cacheEntries = 128;
            ex           = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(mainStore, nWay, cacheEntries));
            StringAssert.Contains(ex.Message, $"N-Way should be less or equal {Cache<int, int>.MaxNWays}");

            nWay         = 4;
            cacheEntries = 129;
            ex           = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(mainStore, nWay, cacheEntries));
            StringAssert.Contains(ex.Message, "Number of total cache entries should be a power of two!");

            nWay         = 4;
            cacheEntries = 0xFFFFFFFF;
            ex           = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(mainStore, nWay, cacheEntries));
            StringAssert.Contains(ex.Message,
                                  $"Number of total cache entries should be less or equal than {Cache<int, int>.MaxCacheEntries}");

            nWay         = 4;
            cacheEntries = 128;
            ex           = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(mainStore, nWay, cacheEntries, null));
            StringAssert.Contains(ex.Message, "Eviction algorithm isn't specified!");

            nWay         = 8;
            cacheEntries = 4;
            ex           = Assert.ThrowsException <ArgumentException>(() => new Cache <int, int>(mainStore, nWay, cacheEntries));
            StringAssert.Contains(ex.Message,
                                  $"Number of total cache entries {cacheEntries} should more or equal than {nWay} ways");
        }
Exemplo n.º 7
0
        public void TestCachePutValue()
        {
            var  mainStore    = new MainStore <int, int>();
            uint nWay         = 4;
            uint cacheEntries = 8;
            var  cache        = new Cache <int, int>(mainStore, nWay, cacheEntries);

            Assert.AreEqual((uint)2, cache.CacheSets);

            mainStore.PutValue(1, 1);
            mainStore.PutValue(2, 2);
            mainStore.PutValue(3, 3);
            mainStore.PutValue(4, 4);
            mainStore.PutValue(5, 5);
            mainStore.PutValue(6, 6);
            mainStore.PutValue(7, 7);
            mainStore.PutValue(8, 8);
            mainStore.PutValue(9, 9);
            mainStore.PutValue(10, 10);
            mainStore.PutValue(11, 11);
            mainStore.PutValue(12, 12);

            cache.PutValue(1, 1);
            cache.PutValue(2, 2);
            cache.PutValue(3, 3);
            cache.PutValue(4, 4);
            cache.PutValue(5, 5);
            cache.PutValue(6, 6);
            cache.PutValue(7, 7);
            cache.PutValue(8, 8);

            int value;

            // all good
            value = cache.TryGetValue(1);
            Assert.AreEqual(1, value);
            value = cache.TryGetValue(2);
            Assert.AreEqual(2, value);
            value = cache.TryGetValue(3);
            Assert.AreEqual(3, value);
            value = cache.TryGetValue(4);
            Assert.AreEqual(4, value);
            value = cache.TryGetValue(5);
            Assert.AreEqual(5, value);
            value = cache.TryGetValue(6);
            Assert.AreEqual(6, value);
            value = cache.TryGetValue(7);
            Assert.AreEqual(7, value);
            value = cache.TryGetValue(8);
            Assert.AreEqual(8, value);

            // not in the cache
            value = cache.TryGetValue(9);
            Assert.AreEqual(9, value);

            //check that 1 got evicted
            var invalidateResult = cache.DeleteValue(1);

            Assert.AreEqual(false, invalidateResult);

            invalidateResult = cache.DeleteValue(2);
            Assert.AreEqual(true, invalidateResult);

            //check exception on search value that is not present
            var ex = Assert.ThrowsException <KeyNotFoundException>(() => cache.TryGetValue(13));

            StringAssert.Contains(ex.Message, "The given key was not present in the dictionary");
        }