public void ClearAllEntries()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
cache.TryAdd("Foo", Task.FromResult("Bar"));
cache.TryAdd("Bar", Task.FromResult("Baz"));
// act
cache.Clear();
// assert
Assert.Equal(0, cache.Usage);
}
public void ClearAllEntries()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
cache.TryAdd("Foo", Task.FromResult("Bar"));
cache.TryAdd("Bar", Task.FromResult("Baz"));
// act
cache.Clear();
// assert
Assert.Equal(0, cache.Usage);
}
public void TryAddTwice()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = new TaskCacheKey("a", "Foo");
var expected = Task.FromResult("Bar");
var another = Task.FromResult("Baz");
// act
var addedFirst = cache.TryAdd(key, expected);
var addedSecond = cache.TryAdd(key, another);
// assert
Task <string> resolved = cache.GetOrAddTask(key, () => Task.FromResult("Quox"));
Assert.True(addedFirst);
Assert.False(addedSecond);
Assert.Same(expected, resolved);
}
public void TryAddTwice()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = "Foo";
var expected = "Bar";
var another = "Baz";
// act
var addedFirst = cache.TryAdd(key, expected);
var addedSecond = cache.TryAdd(key, another);
// assert
var exists = cache.TryGetValue(key, out object actual);
Assert.True(addedFirst);
Assert.False(addedSecond);
Assert.True(exists);
Assert.Equal(expected, (string)actual);
}
public void TryAddValueNull()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = new TaskCacheKey("a", "Foo");
// act
void Verify() => cache.TryAdd(key, default(Task <string>) !);
// assert
Assert.Throws <ArgumentNullException>("value", Verify);
}
public void TryAddValueNull()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = "Foo";
string value = null;
// act
Action verify = () => cache.TryAdd(key, value);
// assert
Assert.Throws <ArgumentNullException>("value", verify);
}
public void TryAddNoException()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = "Foo";
var value = "Bar";
// act
Action verify = () => cache.TryAdd(key, value);
// assert
Assert.Null(Record.Exception(verify));
}
public async Task TryAddTwice()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
var expected = Task.FromResult("Bar");
var another = Task.FromResult("Baz");
// act
var addedFirst = cache.TryAdd(key, expected);
var addedSecond = cache.TryAdd(key, another);
// assert
var exists = cache.TryGetValue(key, out Task <string> actual);
Assert.True(addedFirst);
Assert.False(addedSecond);
Assert.True(exists);
Assert.Equal(await expected.ConfigureAwait(false),
await actual.ConfigureAwait(false));
}
public void TryAddNoException()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
var value = Task.FromResult("Bar");
// act
Action verify = () => cache.TryAdd(key, value);
// assert
Assert.Null(Record.Exception(verify));
}
public void TryAddKeyNull()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
string key = null;
var value = Task.FromResult("Foo");
// act
Action verify = () => cache.TryAdd(key, value);
// assert
Assert.Throws <ArgumentNullException>("key", verify);
}
public void TryAddValueNull()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
Task <string> value = null;
// act
Action verify = () => cache.TryAdd(key, value);
// assert
Assert.Throws <ArgumentNullException>("value", verify);
}
public void TryAddNewCacheEntryWithFactory()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = new TaskCacheKey("a", "Foo");
var expected = Task.FromResult("Bar");
// act
var added = cache.TryAdd(key, () => expected);
// assert
Task <string> resolved = cache.GetOrAddTask(key, () => Task.FromResult("Baz"));
Assert.True(added);
Assert.Same(expected, resolved);
}
public void Usage(string[] values, int expectedUsage)
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
foreach (var value in values)
{
cache.TryAdd($"Key:{value}", value);
}
// act
var result = cache.Usage;
// assert
Assert.Equal(expectedUsage, result);
}
public void TryGetValueResultByInteger()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = 1;
var expected = "Bar";
cache.TryAdd(key, expected);
// act
var result = cache.TryGetValue(key, out object actual);
// assert
Assert.True(result);
Assert.Equal(expected, (string)actual);
}
public void VerifyExpirationTrue()
{
// arrange
var cacheSize = 10;
var slidingExpiration = TimeSpan.FromMilliseconds(500);
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
cache.TryAdd(key, Task.FromResult("Bar"));
// act
var exists = cache.TryGetValue(key, out Task <string> actual);
// assert
Assert.True(exists);
}
public void TryAddNewCacheEntry()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = "Foo";
var expected = "Bar";
// act
var added = cache.TryAdd(key, expected);
// assert
var exists = cache.TryGetValue(key, out object actual);
Assert.True(added);
Assert.True(exists);
Assert.Equal(expected, (string)actual);
}
public async Task VerifyExpirationFalse()
{
// arrange
var cacheSize = 10;
var slidingExpiration = TimeSpan.FromMilliseconds(100);
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
cache.TryAdd(key, Task.FromResult("Bar"));
await Task.Delay(300).ConfigureAwait(false);
// act
var exists = cache.TryGetValue(key, out Task <string> actual);
// assert
Assert.False(exists);
}
public void RemoveEntry()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = "Foo";
cache.TryAdd(key, "Bar");
// act
cache.Remove(key);
// assert
var exists = cache.TryGetValue(key, out object actual);
Assert.False(exists);
Assert.Null(actual);
}
public void RemoveEntry()
{
// arrange
var cacheSize = 10;
var cache = new TaskCache(cacheSize);
var key = new TaskCacheKey("a", "Foo");
var value = Task.FromResult("Bar");
cache.TryAdd(key, value);
// act
cache.TryRemove(key);
// assert
Task <string> retrieved = cache.GetOrAddTask(key, () => Task.FromResult("Baz"));
Assert.NotSame(value, retrieved);
}
public void Usage(string[] values, int expectedUsage)
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
foreach (var value in values)
{
cache.TryAdd($"Key:{value}", Task.FromResult(value));
}
// act
var result = cache.Usage;
// assert
Assert.Equal(expectedUsage, result);
}
public async Task TryGetValueResult()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
var expected = Task.FromResult("Bar");
cache.TryAdd(key, expected);
// act
var result = cache.TryGetValue(key, out Task <string> actual);
// assert
Assert.True(result);
Assert.Equal(await expected.ConfigureAwait(false),
await actual.ConfigureAwait(false));
}
public void RemoveEntry()
{
// arrange
var cacheSize = 10;
TimeSpan slidingExpiration = TimeSpan.Zero;
var cache = new TaskCache <string, string>(cacheSize,
slidingExpiration);
var key = "Foo";
cache.TryAdd(key, Task.FromResult("Bar"));
// act
cache.Remove(key);
// assert
var exists = cache.TryGetValue(key, out Task <string> actual);
Assert.False(exists);
Assert.Null(actual);
}