public void Additional_Set_on_same_key_updates_value()
{
var k = 42;
var v1 = "foo";
var v2 = "bar";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.Set(k, v1, ttl);
set.Set(k, v2, ttl);
Assert.AreEqual(v2, set[k].Value);
}
private PackageUpdater GetInstance(string wikiId, bool create)
{
PackageUpdater instance;
lock (_instances) {
var entry = _instances[wikiId];
if (entry == null)
{
if (!create)
{
return(null);
}
var templatePath = string.Format(_packagePath, wikiId);
if (!Directory.Exists(templatePath))
{
throw new ArgumentException(string.Format("package path '{0}' does not exist", templatePath));
}
instance = new PackageUpdater(templatePath);
_instances.Set(wikiId, instance, _instanceTtl);
}
else
{
instance = entry.Value;
}
}
return(instance);
}
public void Clearing_set_releases_all_items()
{
var changed = false;
var ttl = 10.Seconds();
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.Set(1, "a", ttl);
set.Set(2, "b", ttl);
set.Set(3, "v", ttl);
set.CollectionChanged += (s, e) => changed = true;
Assert.AreEqual(3, set.Count());
Assert.IsFalse(changed);
set.Clear();
Assert.AreEqual(0, set.Count());
Assert.IsTrue(changed);
}
public void Can_access_dictionary_during_expiration_event()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(1);
ExpiringDictionary <int, string> .Entry entry = null;
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => {
entry = e.Entry;
set.Delete(e.Entry.Key);
expired.Set();
};
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, ttl);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(ttl.WithoutMilliseconds(), entry.TTL.WithoutMilliseconds());
Assert.IsNull(set[k]);
}
public void Can_reset_expiration()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(2);
ExpiringDictionary <int, string> .Entry entry = null;
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, ttl);
Assert.IsTrue(changed.WaitOne(500));
changed.Reset();
Thread.Sleep(500);
Assert.IsFalse(expired.WaitOne(500));
var oldExpire = set[k].When;
set.RefreshExpiration(k);
Assert.Greater(set[k].When.WithoutMilliseconds(), oldExpire.WithoutMilliseconds());
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
public void Adding_item_after_all_current_items_have_expired_expires_as_expected()
{
var expired = new AutoResetEvent(false);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => expired.Set();
set.Set(1, "b", 2.Seconds());
set.Set(2, "c", 1.Seconds());
Assert.IsTrue(expired.WaitOne(2000));
Assert.IsNull(set[2]);
Assert.IsTrue(expired.WaitOne(2000));
Assert.IsNull(set[1]);
set.Set(3, "a", 500.Milliseconds());
Assert.IsTrue(expired.WaitOne(2000));
Assert.IsNull(set[3]);
}
public void New_item_with_more_recent_expiration_will_fire_at_expected_time()
{
var expired = new ManualResetEvent(false);
var entries = new List <int>();
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entries.Add(e.Entry.Key); expired.Set(); };
var n = 1000;
for (var i = 0; i < n; i++)
{
set.Set(i, "v" + i, TimeSpan.FromMinutes(10));
}
set.Set(100000, "bar", TimeSpan.FromSeconds(2));
Assert.IsTrue(expired.WaitOne(4000));
Assert.AreEqual(1, entries.Count);
Assert.AreEqual(n, set.Count());
}
public static bool wincache_ucache_set(ExpiringDictionary <string, object> _DictionaryTable, String key, object value, int ttl)
{
try
{
if (ttl == 0)
{
_DictionaryTable.Set(key, value);
}
else
{
_DictionaryTable.Set(key, value, new TimeSpan(0, 0, ttl));
}
return(true);
}
catch
{
return(false);
}
}
public static bool wincache_ucache_set(String key, object value, int ttl)
{
try
{
if (ttl == 0)
{
DUserTables.Set(key, value);
}
else
{
DUserTables.Set(key, value, new TimeSpan(0, 0, ttl));
}
return(true);
}
catch
{
return(false);
}
}
public void Disposing_set_expires_all_items_before_dispose_returns_but_does_not_trigger_collection_changed()
{
var expired = false;
var changed = false;
var expiredEntries = new List <string>();
var ttl = TimeSpan.FromSeconds(1);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { expiredEntries.Add(e.Entry.Key + ":" + e.Entry.Value); expired = true; };
set.CollectionChanged += (s, e) => { changed = true; };
set.Set(12, "foo", ttl);
set.Set(21, "bar", ttl);
Assert.IsFalse(expired, "expired was triggered");
Assert.IsTrue(changed, "changed wasn't triggered");
changed = false;
set.Dispose();
Assert.IsFalse(changed, "changed was triggered");
Assert.IsTrue(expired, "expired wasn't triggered");
Assert.AreEqual(new[] { "12:foo", "21:bar" }, expiredEntries.OrderBy(x => x).ToArray());
}
public void SetExpiration_updates_expiration_time()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var ttl2 = TimeSpan.FromSeconds(50);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.Set(k, v, ttl);
Assert.IsTrue(set.SetExpiration(k, ttl2));
Assert.AreEqual(ttl2.WithoutMilliseconds(), set[k].TTL.WithoutMilliseconds());
}
public void Update_changes_value()
{
var k = 42;
var v1 = "foo";
var v2 = "bar";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.Set(k, v1, ttl);
Assert.IsTrue(set.Update(k, v2));
Assert.AreEqual(v2, set[k].Value);
}
public void Access_on_tasktimerfactory_ctor_set_does_not_reset_expiration()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
var expireTime = GlobalClock.UtcNow.AddSeconds(10);
set.Set(k, v, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[k];
AssertEx.AreEqual(ttl, entry.TTL);
Assert.AreEqual(expireTime, entry.When);
}
public void Set_will_fire_in_order_of_expirations()
{
var expired = new ManualResetEvent(false);
var keys = new List <int>();
var values = new List <string>();
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => {
keys.Add(e.Entry.Key);
values.Add(e.Entry.Value);
expired.Set();
};
set.Set(3, "c", TimeSpan.FromMilliseconds(1600));
set.Set(2, "b", TimeSpan.FromMilliseconds(1500));
set.Set(5, "e", TimeSpan.FromMilliseconds(3000));
set.Set(4, "d", TimeSpan.FromMilliseconds(2000));
set.Set(1, "a", TimeSpan.FromMilliseconds(500));
Assert.IsTrue(expired.WaitOne(1000));
Assert.AreEqual(1, keys.Count);
Assert.IsTrue(Wait.For(() => keys.Count == 5, TimeSpan.FromSeconds(5000)));
Assert.AreEqual(new[] { 1, 2, 3, 4, 5 }, keys.ToArray());
Assert.AreEqual(new[] { "a", "b", "c", "d", "e" }, values.ToArray());
}
public void Can_retrieve_item_checking_when()
{
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
var k = 42;
var v = "foo";
var when = DateTime.UtcNow.AddDays(1);
set.Set(k, v, when);
var entry = set[k];
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(when.WithoutMilliseconds(), entry.When.WithoutMilliseconds());
}
public void Can_retrieve_item_checking_ttl()
{
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
set.Set(k, v, ttl);
var entry = set[k];
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(ttl.WithoutMilliseconds(), entry.TTL.WithoutMilliseconds());
}
public void Access_on_tasktimerfactory_ctor_set_does_not_reset_expiration()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
var expireTime = DateTime.UtcNow.AddSeconds(10);
set.Set(k, v, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[k];
AssertEx.AreEqual(ttl, entry.TTL);
Assert.AreEqual(expireTime, entry.When);
}
public void Access_on_autoRefresh_set_does_reset_expiration()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current, true);
var expireTime = GlobalClock.UtcNow.AddSeconds(10);
set.Set(k, v, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[k];
Assert.AreEqual(Math.Round(ttl.TotalSeconds), Math.Round(entry.TTL.TotalSeconds));
Assert.AreNotEqual(expireTime, entry.When);
Assert.GreaterOrEqual(entry.When, expireTime);
Assert.LessOrEqual(entry.When, expireTime.AddSeconds(3));
}
public void Refresh_in_autoRefresh_dictionary_only_fires_every_half_second()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current, true);
var expireTime = DateTime.UtcNow.AddSeconds(10);
set.Set(k, v, expireTime);
var when = set[k].When;
Thread.Sleep(200);
Assert.AreEqual(when.WithoutMilliseconds(), set[k].When.WithoutMilliseconds());
Thread.Sleep(1000);
Assert.Less(when.WithoutMilliseconds(), set[k].When.WithoutMilliseconds());
}
public void Access_on_autoRefresh_set_does_reset_expiration()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current, true);
var expireTime = DateTime.UtcNow.AddSeconds(10);
set.Set(k, v, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[k];
Assert.AreEqual(Math.Round(ttl.TotalSeconds), Math.Round(entry.TTL.TotalSeconds));
Assert.AreNotEqual(expireTime, entry.When);
Assert.GreaterOrEqual(entry.When, expireTime);
Assert.LessOrEqual(entry.When, expireTime.AddSeconds(3));
}
public void Can_dispose_set()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(1);
ExpiringDictionary <int, string> .Entry entry = null;
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, ttl);
set.Dispose();
Assert.IsTrue(changed.WaitOne(2000));
Assert.IsFalse(expired.WaitOne(2000));
}
public void Can_iterate_over_items()
{
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
var n = 10;
for (var i = 1; i <= n; i++)
{
set.Set(i, "v" + i, TimeSpan.FromSeconds(i));
}
var items = from x in set select x;
Assert.AreEqual(n, items.Count());
for (var i = 1; i <= n; i++)
{
// ReSharper disable AccessToModifiedClosure
Assert.IsTrue((from x in set where x.Key == i && x.Value == "v" + x.Key && x.TTL.WithoutMilliseconds() == TimeSpan.FromSeconds(i) select x).Any());
// ReSharper restore AccessToModifiedClosure
}
}
public void Can_set_item_via_when()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var when = DateTime.UtcNow.AddSeconds(1);
ExpiringDictionary <int, string> .Entry entry = null;
var set = new ExpiringDictionary <int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, when);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(when.WithoutMilliseconds(), entry.When.WithoutMilliseconds());
Assert.IsNull(set[k]);
}
public void Update_changes_value()
{
var k = 42;
var v1 = "foo";
var v2 = "bar";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.Set(k, v1, ttl);
Assert.IsTrue(set.Update(k, v2));
Assert.AreEqual(v2, set[k].Value);
}
public void Set_will_fire_in_order_of_expirations()
{
var expired = new ManualResetEvent(false);
var keys = new List<int>();
var values = new List<string>();
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => {
keys.Add(e.Entry.Key);
values.Add(e.Entry.Value);
expired.Set();
};
set.Set(3, "c", TimeSpan.FromMilliseconds(1600));
set.Set(2, "b", TimeSpan.FromMilliseconds(1500));
set.Set(5, "e", TimeSpan.FromMilliseconds(3000));
set.Set(4, "d", TimeSpan.FromMilliseconds(2000));
set.Set(1, "a", TimeSpan.FromMilliseconds(500));
Assert.IsTrue(expired.WaitOne(1000));
Assert.AreEqual(1, keys.Count);
Assert.IsTrue(Wait.For(() => keys.Count == 5, TimeSpan.FromSeconds(5000)));
Assert.AreEqual(new[] { 1, 2, 3, 4, 5 }, keys.ToArray());
Assert.AreEqual(new[] { "a", "b", "c", "d", "e" }, values.ToArray());
}
public void SetExpiration_updates_expiration_time()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var ttl2 = TimeSpan.FromSeconds(50);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.Set(k, v, ttl);
Assert.IsTrue(set.SetExpiration(k, ttl2));
Assert.AreEqual(ttl2.WithoutMilliseconds(), set[k].TTL.WithoutMilliseconds());
}
public void Refresh_in_autoRefresh_dictionary_only_fires_every_half_second()
{
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current, true);
var expireTime = GlobalClock.UtcNow.AddSeconds(10);
set.Set(k, v, expireTime);
var when = set[k].When;
Thread.Sleep(200);
Assert.AreEqual(when.WithoutMilliseconds(), set[k].When.WithoutMilliseconds());
Thread.Sleep(1000);
Assert.Less(when.WithoutMilliseconds(), set[k].When.WithoutMilliseconds());
}
public void New_item_with_more_recent_expiration_will_fire_at_expected_time()
{
var expired = new ManualResetEvent(false);
var entries = new List<int>();
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entries.Add(e.Entry.Key); expired.Set(); };
var n = 1000;
for(var i = 0; i < n; i++) {
set.Set(i, "v" + i, TimeSpan.FromMinutes(10));
}
set.Set(100000, "bar", TimeSpan.FromSeconds(2));
Assert.IsTrue(expired.WaitOne(4000));
Assert.AreEqual(1, entries.Count);
Assert.AreEqual(n, set.Count());
}
public void Can_iterate_over_items()
{
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
var n = 10;
for(var i = 1; i <= n; i++) {
set.Set(i, "v" + i, TimeSpan.FromSeconds(i));
}
var items = from x in set select x;
Assert.AreEqual(n, items.Count());
for(var i = 1; i <= n; i++) {
// ReSharper disable AccessToModifiedClosure
Assert.IsTrue((from x in set where x.Key == i && x.Value == "v" + x.Key && x.TTL.WithoutMilliseconds() == TimeSpan.FromSeconds(i) select x).Any());
// ReSharper restore AccessToModifiedClosure
}
}
public void Clearing_set_releases_all_items()
{
var changed = false;
var ttl = 10.Seconds();
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.Set(1, "a", ttl);
set.Set(2, "b", ttl);
set.Set(3, "v", ttl);
set.CollectionChanged += (s, e) => changed = true;
Assert.AreEqual(3, set.Count());
Assert.IsFalse(changed);
set.Clear();
Assert.AreEqual(0, set.Count());
Assert.IsTrue(changed);
}
public void Can_set_ttl_on_existing_item()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
ExpiringDictionary<int, string>.Entry entry = null;
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, ttl);
Assert.IsTrue(changed.WaitOne(2000));
changed.Reset();
Assert.IsFalse(expired.WaitOne(2000));
set.SetExpiration(k, TimeSpan.FromSeconds(1));
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
public void Can_set_item_via_when()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var when = GlobalClock.UtcNow.AddSeconds(1);
ExpiringDictionary<int, string>.Entry entry = null;
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, when);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(when.WithoutMilliseconds(), entry.When.WithoutMilliseconds());
Assert.IsNull(set[k]);
}
public void Can_set_item_via_ttl()
{
_log.Debug("running test");
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(1);
ExpiringDictionary<int, string>.Entry entry = null;
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, ttl);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(ttl.WithoutMilliseconds(), entry.TTL.WithoutMilliseconds());
Assert.IsNull(set[k]);
}
public void Can_retrieve_item_checking_when()
{
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
var k = 42;
var v = "foo";
var when = GlobalClock.UtcNow.AddDays(1);
set.Set(k, v, when);
var entry = set[k];
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(when.WithoutMilliseconds(), entry.When.WithoutMilliseconds());
}
public void Can_retrieve_item_checking_ttl()
{
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(10);
set.Set(k, v, ttl);
var entry = set[k];
Assert.AreEqual(k, entry.Key);
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(ttl.WithoutMilliseconds(), entry.TTL.WithoutMilliseconds());
}
public void Can_reset_expiration()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var k = 42;
var v = "foo";
var ttl = TimeSpan.FromSeconds(2);
ExpiringDictionary<int, string>.Entry entry = null;
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.Set(k, v, ttl);
Assert.IsTrue(changed.WaitOne(500));
changed.Reset();
Thread.Sleep(500);
Assert.IsFalse(expired.WaitOne(500));
var oldExpire = set[k].When;
set.RefreshExpiration(k);
Assert.Greater(set[k].When.WithoutMilliseconds(), oldExpire.WithoutMilliseconds());
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
public void Disposing_set_expires_all_items_before_dispose_returns_but_does_not_trigger_collection_changed()
{
var expired = false;
var changed = false;
var expiredEntries = new List<string>();
var ttl = TimeSpan.FromSeconds(1);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { expiredEntries.Add(e.Entry.Key + ":" + e.Entry.Value); expired = true; };
set.CollectionChanged += (s, e) => { changed = true; };
set.Set(12, "foo", ttl);
set.Set(21, "bar", ttl);
Assert.IsFalse(expired, "expired was triggered");
Assert.IsTrue(changed, "changed wasn't triggered");
changed = false;
set.Dispose();
Assert.IsFalse(changed, "changed was triggered");
Assert.IsTrue(expired, "expired wasn't triggered");
Assert.AreEqual(new[] { "12:foo", "21:bar" }, expiredEntries.OrderBy(x => x).ToArray());
}
public void Adding_item_after_all_current_items_have_expired_expires_as_expected()
{
var expired = new AutoResetEvent(false);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => expired.Set();
set.Set(1, "b", 2.Seconds());
set.Set(2, "c", 1.Seconds());
Assert.IsTrue(expired.WaitOne(2000));
Assert.IsNull(set[2]);
Assert.IsTrue(expired.WaitOne(2000));
Assert.IsNull(set[1]);
set.Set(3, "a", 500.Milliseconds());
Assert.IsTrue(expired.WaitOne(2000));
Assert.IsNull(set[3]);
}
public void Additional_Set_on_same_key_updates_value()
{
var k = 42;
var v1 = "foo";
var v2 = "bar";
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringDictionary<int, string>(TaskTimerFactory.Current);
set.Set(k, v1, ttl);
set.Set(k, v2, ttl);
Assert.AreEqual(v2, set[k].Value);
}
