public void WhenTimeoutIsReachedNoDataIsReturned()
		{
			_loadDataCalled = 0;
			object result = null;
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));

			var waiter = (FluentResultBuilder)target.AddAndGet(new CacheDefinition
			{
				Id = "test",
				LoadData = () => LoadDataWithWait(20, 5),
				ExpireAfter = TimeSpan.FromMilliseconds(3)
			}, (r) => result = r);
			target.Execute().Count();	//Initialize 
			var task = Task.Run(() =>
			{
				for (int i = 0; i < 8; i++)
				{
					_runner.RunCycle();//Fun the getter function
				}
			});
			Task.WaitAll(task);
			target.Execute().Count();	//Initialize 
			target.Execute().Count();	//Initialize 


			Assert.IsNull(result);
			Assert.AreEqual(1, _loadDataCalled);
		}
		public void AddAndGetNonExistingItemWithTimeoutWillNotSetTheValue()
		{
			_loadDataCalled = 0;
			object result = null;
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));

			var waiter = (FluentResultBuilder)target.AddAndGet(new CacheDefinition
			{
				Id = "test",
				LoadData = () => LoadData(20)
			}, (r) => result = r);
			target.Execute().Count();	//Initialize 
			//Fun the getter function
			_runner.RunCycle(6);
			target.Execute().Count();	//Initialize 
			target.Execute().Count();	//Initialize 

			//ExecuteEnumerator(waiter.NestedEnumerator);
			Assert.IsNull(result);
			Assert.AreEqual(1, _loadDataCalled);
		}
		public void ItShouldBePossibleToAddUpdateItemDuplicateShouldUpdateCd()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddItem(new CacheDefinition
			{
				Value = "testValue",
				Id = "testId"
			});
			target.Execute().Count();


			target.AddOrUpdateItem(new CacheDefinition
			{
				Value = "testValueDifferent",
				Id = "testId"
			});
			target.Execute().Count();

			var item = target.GetItems("")["testId"];
			Assert.AreEqual("testValueDifferent", item.Value);
		}
		public void ItShouldBePossibleToInvalidateItemNoItemShouldDoNothing()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));

			target.InvalidateItem("testId");
			target.Execute().Count();

			Assert.IsFalse(target.GetItems("").ContainsKey("testId"));
		}
		public void ItShouldBePossibleToAddUpdateItemDuplicateShouldUpdate()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddItem("testId", "testValue");
			target.Execute().Count();

			target.AddOrUpdateItem("testId", "testValueChange");
			target.Execute().Count();

			var item = target.GetItems("")["testId"];
			Assert.AreEqual("testValueChange", item.Value);
		}
		public void ItShouldBePossibleToAddUpdateItemWithCd()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddOrUpdateItem(new CacheDefinition
			{
				Value = "testValue",
				Id = "testId"
			});
			target.Execute().Count();

			var group = target.Groups[string.Empty];
			Assert.IsTrue(target.GetItems("").ContainsKey("testId"));
			var item = target.GetItems("")["testId"];
			Assert.AreEqual(group.ExpireAfter, item.ExpireAfter);
			Assert.AreEqual("testValue", item.Value);
			Assert.IsFalse(target.Groups.ContainsKey("test"));
		}
		public void ItShouldBePossibleToAddUpdateItemToSpecificGroup()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddGroup(new CacheGroupDefinition
			{
				Id = "testGroup",
				Capped = 1000,
				ExpireAfter = TimeSpan.FromMilliseconds(500),
				RollingExpiration = true
			});
			target.Execute().Count();
			target.AddOrUpdateItem("testId", "testValue", "testGroup");
			target.Execute().Count();

			var group = target.Groups["testGroup"];
			Assert.IsTrue(target.GetItems("testGroup").ContainsKey("testId"));
			var item = target.GetItems("testGroup")["testId"];
			Assert.AreEqual(group.ExpireAfter, item.ExpireAfter);
			Assert.AreEqual("testValue", item.Value);
		}
		public void ItShouldBePossibleToAddItemToDefaultGroup()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddItem("testId", "testValue");
			target.Execute().Count();

			var group = target.Groups[string.Empty];
			Assert.IsTrue(target.GetItems("").ContainsKey("testId"));
			var item = target.GetItems("")["testId"];
			Assert.AreEqual(group.ExpireAfter, item.ExpireAfter);
			Assert.AreEqual("testValue", item.Value);
		}
		public void ItShouldBePossibleToRemoveGroupNoGroupShouldDoNothing()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));

			target.RemoveGroup("notExisting");
			target.Execute().Count();

			Assert.AreEqual(1, target.Groups.Count);
			Assert.IsFalse(target.Groups.ContainsKey("notExisting"));
		}
		public void ItShouldBePossibleToRemoveGroup()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddGroup(new CacheGroupDefinition
			{
				Id = "test",
				Capped = 1000,
				ExpireAfter = TimeSpan.FromMilliseconds(500),
				RollingExpiration = true
			});
			target.Execute().Count();
			Assert.AreEqual(2, target.Groups.Count);

			target.RemoveGroup("test");
			target.Execute().Count();

			Assert.AreEqual(1, target.Groups.Count);
			Assert.IsFalse(target.Groups.ContainsKey("test"));
		}
		public void ItShouldBePossibleToAddGroupUpdatingShouldThrow()
		{
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddGroup(new CacheGroupDefinition
				{
					Id = "test",
					Capped = 1000,
					ExpireAfter = TimeSpan.FromMilliseconds(500),
					RollingExpiration = true
				});
			target.Execute().Count();

			Exception resultEx = null;
			try
			{
				target.AddGroup(new CacheGroupDefinition
				{
					Id = "test",
					Capped = 100,
					ExpireAfter = TimeSpan.FromMilliseconds(500),
					RollingExpiration = true
				});
			}
			catch (Exception ex)
			{
				resultEx = ex;
			}
			Assert.IsNotNull(resultEx);
		}