public void TestDequeueByInsertion()
{
var test = new LurchTableTest <int, string>(LurchTableOrder.Insertion);
Assert.AreEqual(LurchTableOrder.Insertion, test.Ordering);
var sample = GetSample();
Array.Reverse(sample);
foreach (var item in sample)
{
test.Add(item.Key, item.Value);
}
KeyValuePair <int, string> value;
foreach (var item in sample)
{
Assert.IsTrue(test.Peek(out value));
Assert.AreEqual(item.Key, value.Key);
Assert.AreEqual(item.Value, value.Value);
value = test.Dequeue();
Assert.AreEqual(item.Key, value.Key);
Assert.AreEqual(item.Value, value.Value);
}
Assert.IsFalse(test.Peek(out value));
Assert.IsFalse(test.TryDequeue(out value));
}
public void TestAddRemoveByKey()
{
LurchTableTest <int, string> test = new LurchTableTest <int, string>();
for (int i = 0; i < 10; i++)
{
test.Add(i, i.ToString());
}
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(test.ContainsKey(i));
}
string cmp;
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(test.TryGetValue(i, out cmp) && cmp == i.ToString());
}
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(test.Remove(i));
}
}
public void TestTryRoutines()
{
var data = new LurchTableTest <int, string>();
Assert.IsTrue(data.TryAdd(1, "a"));
Assert.IsFalse(data.TryAdd(1, "a"));
Assert.IsTrue(data.TryUpdate(1, "a"));
Assert.IsTrue(data.TryUpdate(1, "c"));
Assert.IsTrue(data.TryUpdate(1, "d", "c"));
Assert.IsFalse(data.TryUpdate(1, "f", "c"));
Assert.AreEqual("d", data[1]);
Assert.IsTrue(data.TryUpdate(1, "a", data[1]));
Assert.AreEqual("a", data[1]);
Assert.IsFalse(data.TryUpdate(2, "b"));
string val;
Assert.IsTrue(data.TryRemove(1, out val) && val == "a");
Assert.IsFalse(data.TryRemove(2, out val));
Assert.AreNotEqual(val, "a");
Assert.IsFalse(data.TryUpdate(1, (k, x) => x.ToUpper()));
data[1] = "a";
data[1] = "b";
Assert.IsTrue(data.TryUpdate(1, (k, x) => x.ToUpper()));
Assert.AreEqual("B", data[1]);
}
public void TestAtomicInterfaces()
{
var data = new LurchTableTest <int, string>();
data[1] = "a";
AddUpdateValue update = new AddUpdateValue();
Assert.IsFalse(data.AddOrUpdate(1, ref update));
Assert.AreEqual("a", update.OldValue);
Assert.IsFalse(data.AddOrUpdate(2, ref update));
Assert.IsNull(update.OldValue);
Assert.IsFalse(data.TryRemove(1, ref update));
Assert.AreEqual("a", update.OldValue);
Assert.AreEqual(1, data.Count);
Assert.AreEqual("a", data[1]);
update.Value = "b";
Assert.IsTrue(data.AddOrUpdate(1, ref update));
Assert.AreEqual("a", update.OldValue);
Assert.IsTrue(data.AddOrUpdate(2, ref update));
Assert.IsNull(update.OldValue);
Assert.AreEqual(2, data.Count);
Assert.AreEqual("b", data[1]);
Assert.AreEqual("b", data[2]);
Assert.IsTrue(data.TryRemove(1, ref update));
Assert.AreEqual("b", update.OldValue);
Assert.IsTrue(data.TryRemove(2, ref update));
Assert.AreEqual("b", update.OldValue);
Assert.AreEqual(0, data.Count);
}
public void TestAtomicAddOrUpdate()
{
var data = new LurchTableTest <int, string>();
int[] counter = new int[] { -1 };
for (int i = 0; i < 100; i++)
{
data.AddOrUpdate(i, (k) => (++counter[0]).ToString(), (k, v) => { throw new InvalidOperationException(); });
}
for (int i = 0; i < 100; i++)
{
Assert.AreEqual((i & 1) == 1, data.TryRemove(i, (k, v) => (int.Parse(v) & 1) == 1));
}
for (int i = 0; i < 100; i++)
{
data.AddOrUpdate(i, (k) => (++counter[0]).ToString(), (k, v) => (++counter[0]).ToString());
}
Assert.AreEqual(100, data.Count);
Assert.AreEqual(200, counter[0] + 1);
for (int i = 0; i < 100; i++)
{
Assert.IsTrue(data.TryRemove(i, (k, v) => int.Parse(v) - 100 == i));
}
Assert.AreEqual(0, data.Count);
}
public void TestDequeueByModified()
{
var test = new LurchTableTest <int, string>(LurchTableOrder.Modified);
Assert.AreEqual(LurchTableOrder.Modified, test.Ordering);
var sample = GetSample();
foreach (var item in sample)
{
test.Add(item.Key, item.Value);
}
Array.Reverse(sample);
for (int i = 0; i < sample.Length; i++)
{
var item = new KeyValuePair <int, string>(sample[i].Key, sample[i].Value + "-2");
test[item.Key] = item.Value;
sample[i] = item;
}
KeyValuePair <int, string> value;
foreach (var item in sample)
{
Assert.IsTrue(test.Peek(out value));
Assert.AreEqual(item.Key, value.Key);
Assert.AreEqual(item.Value, value.Value);
value = test.Dequeue();
Assert.AreEqual(item.Key, value.Key);
Assert.AreEqual(item.Value, value.Value);
}
Assert.IsFalse(test.Peek(out value));
Assert.IsFalse(test.TryDequeue(out value));
}
public void TestDisposed()
{
IConcurrentDictionary <int, string> test = new LurchTableTest <int, string>(new IntComparer());
test.Dispose();
test.Add(1, "");
}
public void TestInitialize()
{
LurchTableTest <string, string> test = new LurchTableTest <string, string>(StringComparer.Ordinal);
test["a"] = "b";
Assert.AreEqual(1, test.Count);
test.Initialize();
Assert.AreEqual(0, test.Count);
}
public void TestValues()
{
LurchTableTest <string, string> test = new LurchTableTest <string, string>();
test["a"] = "b";
string all = String.Join("", new List <string>(test.Values).ToArray());
Assert.AreEqual("b", all);
}
public void TestKeys()
{
LurchTableTest <string, string> test = new LurchTableTest <string, string>(new StringComparerNoCase());
test["a"] = "b";
string all = String.Join("", new List <string>(test.Keys).ToArray());
Assert.AreEqual("a", all);
}
public void TestGetOrAdd()
{
var data = new LurchTableTest <int, string>();
Assert.AreEqual("a", data.GetOrAdd(1, "a"));
Assert.AreEqual("a", data.GetOrAdd(1, "b"));
Assert.AreEqual("b", data.GetOrAdd(2, k => "b"));
Assert.AreEqual("b", data.GetOrAdd(2, k => "c"));
}
public void TestNewAddOrUpdate()
{
var data = new LurchTableTest <int, string>();
Assert.AreEqual("a", data.AddOrUpdate(1, "a", (k, v) => k.ToString()));
Assert.AreEqual("1", data.AddOrUpdate(1, "a", (k, v) => k.ToString()));
Assert.AreEqual("b", data.AddOrUpdate(2, k => "b", (k, v) => k.ToString()));
Assert.AreEqual("2", data.AddOrUpdate(2, k => "b", (k, v) => k.ToString()));
}
public void TestDisposed()
{
IDictionary <int, string> test = new LurchTableTest <int, string>();
var disposable = test as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
Assert.Throws <ObjectDisposedException>(() => { test.Add(1, ""); });
}
public void TestComparer()
{
var test = new LurchTableTest <string, string>(StringComparer.OrdinalIgnoreCase);
test["a"] = "b";
Assert.IsTrue(test.ContainsKey("A"));
test = new LurchTableTest <string, string>(StringComparer.OrdinalIgnoreCase);
test["a"] = "b";
Assert.IsTrue(test.ContainsKey("A"));
}
public void TestDisposed()
{
IDictionary <int, string> test = new LurchTableTest <int, string>();
var disposable = test as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
test.Add(1, "");
}
public void TestAtomicAdd()
{
var data = new LurchTableTest <int, string>();
int[] counter = new int[] { -1 };
for (int i = 0; i < 100; i++)
{
Assert.IsTrue(data.TryAdd(i, (k) => (++counter[0]).ToString()));
}
Assert.AreEqual(100, data.Count);
Assert.AreEqual(100, counter[0] + 1);
//Inserts of existing keys will not call method
Assert.IsFalse(data.TryAdd(50, (k) => { throw new InvalidOperationException(); }));
Assert.AreEqual(100, data.Count);
}
