public void PolymorphismTest()
        {
            DictionaryMemoryCache<string, Animal> actual = new DictionaryMemoryCache<string, Animal>(TestLoadByStringAnimalMethod);

            Animal animal1 = actual[_Key1];
            Animal animal2 = actual[_Key2];

            Assert.IsNotNull(animal1);
            Assert.IsInstanceOfType(animal1, typeof(Cat));

            Assert.IsNotNull(animal2);
            Assert.IsInstanceOfType(animal2, typeof(Dog));            
            
            //TODO: Investigate use of assignable cache as opposed to look up cache for dictionary and other lookup cache managers
        }
        public void LookupByStringTest()
        {
            DictionaryMemoryCache<string, Cat> actual = new DictionaryMemoryCache<string, Cat>(TestLoadByStringCatMethod);

            Cat cat = actual[_Key1];

            Assert.IsNotNull(cat);            

            Guid expectedUniqueId = cat.UniqueId;

            Cat cat2 = actual[_Key2];

            Assert.IsNotNull(cat2);
            Assert.AreNotSame(cat, cat2);
            Assert.AreNotEqual<Guid>(expectedUniqueId, cat2.UniqueId);
        }
        public void RemoveItemTest()
        {
            DictionaryMemoryCache<string, Cat> actual = new DictionaryMemoryCache<string, Cat>(TestLoadByStringCatMethod);

            Cat cat = actual[_Key1];

            Assert.IsNotNull(cat);            

            Guid originalKey1UniqueId = cat.UniqueId;

            actual.RemoveItem(_Key1);

            Cat cat1TakeTwo = actual[_Key2];

            Assert.IsNotNull(cat1TakeTwo);
            Assert.AreNotSame(cat, cat1TakeTwo);
            Assert.AreNotEqual<Guid>(originalKey1UniqueId, cat1TakeTwo.UniqueId);
        }
 public void DefaultConstructorTest()
 {
     DictionaryMemoryCache<string, int> actual = new DictionaryMemoryCache<string, int>(TestLoadByStringIntMethod);
 }
        public void AbsoluteExpirationTest()
        {
            CacheOptions cacheOptions = new CacheOptions()
            {
                Expiration = CacheExpiration.Absolute,
                CacheDuration = TimeSpan.FromSeconds(2D)
            };
            DictionaryMemoryCache<string, Cat> actual = new DictionaryMemoryCache<string, Cat>(TestLoadByStringCatCloneMethod, cacheOptions);

            Cat cat1 = actual[_Key1];
            Cat cat2 = actual[_Key2];

            Assert.IsNotNull(cat1);
            Assert.IsNotNull(cat2);

            Guid originalCat1UniqueId = cat1.UniqueId;
            Guid originalCat2UniqueId = cat2.UniqueId;

            Cat cat1TakeTwo = actual[_Key1];
            Cat cat2TakeTwo = actual[_Key2];

            Assert.IsNotNull(cat1TakeTwo);
            Assert.IsNotNull(cat2TakeTwo);

            Assert.AreSame(cat1, cat1TakeTwo);
            Assert.AreSame(cat2, cat2TakeTwo);
            Assert.AreEqual<Guid>(originalCat1UniqueId, cat1TakeTwo.UniqueId);
            Assert.AreEqual<Guid>(originalCat2UniqueId, cat2TakeTwo.UniqueId);

            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(3D));

            Cat cat1TakeThree = actual[_Key1];
            Cat cat2TakeThree = actual[_Key2];

            Assert.IsNotNull(cat1TakeThree);
            Assert.IsNotNull(cat2TakeThree);

            Assert.AreEqual<string>(cat1.Name, cat1TakeThree.Name);
            Assert.AreEqual<int>(cat1.ClawLength, cat1TakeThree.ClawLength);
            Assert.AreEqual<string>(cat2.Name, cat2TakeThree.Name);
            Assert.AreEqual<int>(cat2.ClawLength, cat2TakeThree.ClawLength);
            Assert.AreNotEqual<Guid>(originalCat1UniqueId, cat1TakeThree.UniqueId);
            Assert.AreNotEqual<Guid>(originalCat2UniqueId, cat2TakeThree.UniqueId);
        }
        public void ImmediateExpirationTest()
        {
            CacheOptions cacheOptions = new CacheOptions()
            {
                Expiration = CacheExpiration.Immediate
            };
            DictionaryMemoryCache<string, Cat> actual = new DictionaryMemoryCache<string, Cat>(TestLoadByStringCatMethod);

            Cat cat = actual[_Key1];

            Assert.IsNotNull(cat);            

            Cat cat1TakeTwo = actual[_Key2];

            Assert.IsNotNull(cat1TakeTwo);
            Assert.AreNotSame(cat, cat1TakeTwo);
            Assert.AreNotEqual<Guid>(cat.UniqueId, cat1TakeTwo.UniqueId);
        }