Example #1
0
        public void Janitor_AdjustsFrequency_Correctly()
        {
            var janitor = CacheJanitor.Instance;
            var secret = new PrivateObject(janitor);
            var cache1 = new CheckAndSetCache<string, object>(Expires.Always<object>());
            var cache2 = new CheckAndSetCache<string, object>(Expires.Always<object>());
            var cleanup1 = Cleanup.Expired<string, object>(cache1);
            var cleanup2 = Cleanup.Expired<string, object>(cache2);

            cleanup1.Options = new CleanupOptions
            {
                Frequency = TimeSpan.FromMilliseconds(200),
            };
            cleanup2.Options = new CleanupOptions
            {
                Frequency = TimeSpan.FromMilliseconds(100),
            };

            // starts with frequency of 200
            janitor.Register(cache1, cleanup1);
            Assert.AreEqual(cleanup1.Options.Frequency, (TimeSpan)secret.GetField("SleepTime"));

            // starts with frequency of 100
            janitor.Register(cache2, cleanup2);
            Assert.AreEqual(cleanup2.Options.Frequency, (TimeSpan)secret.GetField("SleepTime"));

            janitor.Unregister(cache1);
            janitor.Unregister(cache2);
        }
 public void CheckAndSetCache_Clear_Works()
 {
     var strategy = Expires.Always<object>();
     using (var cache = new CheckAndSetCache<string, object>(strategy))
     {
         cache.Add("1", 1);
         cache.Add("2", 2);
         cache.Add("3", 3);
         Assert.AreEqual(3, cache.Count);
         cache.Clear();
         Assert.AreEqual(0, cache.Count);
     }
 }
 public void CheckAndSetCache_Clean_Works()
 {
     var strategy = new GenericExpirationStrategy<object>(v => (int)v.Value == 2);
     using (var cache = new CheckAndSetCache<string, object>(strategy))
     {
         cache.Add("1", 1);
         cache.Add("2", 2);
         cache.Add("3", 3);
         Assert.AreEqual(3, cache.Count);
         cache.Clean();
         Assert.AreEqual(2, cache.Count);
     }
 }
        public void CheckAndSetCache_AddAndRemove_Works()
        {
            using (var cache = new CheckAndSetCache<string, object>())
            {
                cache.Add("1", 1);
                cache.Add("2", (k) => (object)int.Parse(k));
                cache.Add("3", 3, (k) => (object)int.Parse(k));
                Assert.AreEqual(3, cache.Count);

                var result = new List<string> { "1", "2", "3" }.All(cache.Remove);
                Assert.IsTrue(result);
                Assert.AreEqual(0, cache.Count);
            }
        }
        public void CheckAndSetCache_Enumeration_Works()
        {
            var strategy = Expires.Never<object>();
            var cache = new CheckAndSetCache<string, object>(strategy)
            {
                { "1", 1 },
                { "2", 2 },
                { "3", 3 },
            };

            foreach (var item in cache)
            {
                Assert.AreEqual(item.Value.Value, (int)cache[item.Key]);
            }

            // just to get 100%
            var enumerable = ((System.Collections.IEnumerable)cache).GetEnumerator();
        }
Example #6
0
        public void Janitor_CleansUp_Correctly()
        {
            var janitor = CacheJanitor.Instance;
            var secret = new PrivateObject(janitor);
            var cache = new CheckAndSetCache<string, object>(Expires.Always<object>())
            {
                { "key1", "value1" },
                { "key2", "value2" },
                { "key3", "value3" },
            };
            var cleanup = Cleanup.Expired<string, object>(cache);
            cleanup.Options = new CleanupOptions
            {
                Frequency = TimeSpan.FromMilliseconds(50),
            };

            Assert.AreEqual(3, cache.Count);
            janitor.Register(cache, cleanup);
            // cleanup starts
            Thread.Sleep(TimeSpan.FromMilliseconds(100));
            Assert.AreEqual(0, cache.Count);
            janitor.Unregister(cache);
        }
 public void CheckAndSetCache_GetExpired_Works()
 {
     var strategy = Expires.Always<object>();
     var cache = new CheckAndSetCache<string, object>(strategy);
     cache.Add("1", 1);
     Assert.AreEqual(null, cache.Get("1"));
     Assert.AreEqual(null, cache.Get("2"));
 }
Example #8
0
        public void Janitor_RegistersTwice_Correctly()
        {
            var janitor = CacheJanitor.Instance;
            var secret = new PrivateObject(janitor);
            var cache = new CheckAndSetCache<string, object>(Expires.Always<object>());
            var hashcode = cache.GetHashCode();

            janitor.Register(cache, Cleanup.Expired<string, object>(cache));
            janitor.Register(cache, Cleanup.Expired<string, object>(cache));
            // TODO validate later
            Assert.IsTrue(janitor.Unregister(cache));
        }
Example #9
0
        public void Janitor_RegistersAndStarts_Correctly()
        {
            var janitor = CacheJanitor.Instance;
            var secret = new PrivateObject(janitor);
            var cache = new CheckAndSetCache<string, object>(Expires.Always<object>());

            Assert.AreEqual(TaskStatus.Created, ((Task)secret.GetField("_janitor")).Status);
            janitor.Register(cache, Cleanup.Expired<string, object>(cache));
            Thread.Sleep(TimeSpan.FromMilliseconds(50));
            Assert.AreEqual(TaskStatus.Running, ((Task)secret.GetField("_janitor")).Status);
            janitor.Unregister(cache);
        }