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 ItShouldBePossibleToAddAndGetNotExistingItem()
		{
			_loadDataCalled = 0;
			object result = null;
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			var cr = new NodeCacheCoroutine(target);
			_runner.StartCoroutine(cr);
			_runner.RunCycle();

			var waiter = (FluentResultBuilder)target.AddAndGet(new CacheDefinition
			{
				Id = "test",
				LoadData = () => LoadDataWithWait(10, 5)
			}, (r) =>
			{
				result = r;
			});
			_runner.StartCoroutine(waiter.AsCoroutine());
			_runner.RunCycleFor(200);

			Assert.AreEqual(1, _loadDataCalled);
			Assert.AreEqual("RESULT", result);
		}
		public void ItShouldBePossibleToAddAndGetAnAlreadyExistingItem()
		{
			_loadDataCalled = 0;
			object result = null;
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			target.AddItem("test", "RESULT");
			_runner.StartCoroutine(new NodeCacheCoroutine(target));
			_runner.RunCycle();		//Initialize node cache coroutine

			var waiter = (FluentResultBuilder)target.AddAndGet(new CacheDefinition
			{
				Id = "test",
				LoadData = () => LoadData(5),
				ExpireAfter = TimeSpan.FromMinutes(1)
			}, (r) =>
			{
				result = r;
			});
			_runner.StartCoroutine(waiter.AsCoroutine());
			//target.Execute().Count();	//Initialize 
			_runner.RunCycle();

			Assert.AreEqual("RESULT", result);
			Assert.AreEqual(0, _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 OverlappingRequestWillNotInvokeTwiceTheLoadDataButWillHaveTheSameResult()
		{
			_loadDataCalled = 0;
			object result1 = null;
			object result2 = null;
			var target = new NodeCache(_runner,TimeSpan.FromSeconds(10));
			_runner.StartCoroutine(new NodeCacheCoroutine(target));
			_runner.RunCycle();		//Initialize node cache coroutine

			var waiter1 = (FluentResultBuilder)target.AddAndGet(new CacheDefinition
			{
				Id = "test",
				LoadData = () => LoadData(5)
			}, (r) =>
			{
				result1 = r;
			});
			_runner.StartCoroutine(waiter1.AsCoroutine());
			var waiter2 = (FluentResultBuilder)target.AddAndGet(new CacheDefinition
			{
				Id = "test",
				LoadData = () => LoadData(5, "ANOTHER THING"),
				ExpireAfter = TimeSpan.FromMinutes(5)
			}, (r) =>
			{
				result2 = r;
			});
			_runner.StartCoroutine(waiter2.AsCoroutine());
			_runner.RunCycle();	//Load the coroutines
			_runner.RunCycle();	//Start the coroutines methods
			_runner.RunCycle(5);	//Wait for completion
			_runner.RunCycle();	//Copy the data

			Assert.AreEqual(1, _loadDataCalled);
			Assert.AreEqual("RESULT", result1, "Result 1 is " + result1);
			Assert.AreEqual("RESULT", result2, "Result 2 is " + result1);
		}