public void RemoveReturnsFalseIfSetDoesNotContainItem()
{
var set = new ConcurrentCountedSet <string>();
bool result = set.Remove("foo");
Assert.IsFalse(result);
}
public void ConcurrentCountedSetInitialisesWithSpecifiedCollection()
{
var set = new ConcurrentCountedSet <string>(new[] { "foo", "foo", "bar" });
Assert.IsNotNull(set);
Assert.AreEqual(2, set.Count);
}
public void ConcurrentCountedSetClearEmptiesSet()
{
var set = new ConcurrentCountedSet <string>(new[] { "foo", "foo", "bar" });
set.Clear();
Assert.IsEmpty(set);
}
public void ConcurrentCountedSetTryGetCountReturnsFalseIfItemIsNotPresent()
{
var set = new ConcurrentCountedSet <string>();
bool result = set.TryGetCount("foo", out _);
Assert.IsFalse(result);
}
public void ConcurrentCountedSetAddsItem()
{
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
Assert.AreEqual(1, set.Count);
}
public void ConcurrentCountedSetTryGetCountReturnsZeroIfItemIsNotPresent()
{
var set = new ConcurrentCountedSet <string>();
int count;
Assert.IsFalse(set.TryGetCount("foo", out count));
Assert.AreEqual(0, count);
}
public void IfItemIsAddedToSetOnceRemoveCompletelyRemovesItem()
{
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.Remove("foo");
Assert.IsFalse(set.Contains("foo"));
}
public void IfItemIsAddedToSetOnceAssociatedCountIsOne()
{
int count = 0;
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.TryGetCount("foo", out count);
Assert.AreEqual(1, count);
}
public void IfItemIsAddedToSetMultipleTimesRemoveDoesNotCompletelyRemoveItem()
{
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.Add("foo");
set.Remove("foo");
Assert.IsTrue(set.Contains("foo"));
}
public void ConcurrentCountedSetSupportsLookupByKey()
{
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.Add("foo");
int count = set["foo"];
Assert.AreEqual(2, count);
}
public void AtomicBooleanGetAndSetReturnsOriginalValueMultiThreaded()
{
const int expected = 1000;
ConcurrentCountedSet <bool> values = new ConcurrentCountedSet <bool>();
var b = new AtomicBoolean(true);
System.Threading.Tasks.Parallel.For(0, 1000, i => values.Add(b.GetAndSet(i % 2 == 0)));
Assert.AreEqual(expected, values[true] + values[false]);
}
public void AtomicBooleanCompareAndSetReturnsExpectedValuesForFailedMatchesMultiThreaded()
{
const int expected = 1000;
var b = new AtomicBoolean(true);
var values = new ConcurrentCountedSet <bool>();
System.Threading.Tasks.Parallel.For(0, 1000, i => values.Add(b.CompareAndSet(i % 2 != 0, false)));
Assert.AreEqual(expected, values[true] + values[false]);
}
public void AtomicObjectCompareAndSetReturnsExpectedValuesForFailedMatchesMultiThreaded()
{
const int expected = 1000;
var o = new AtomicObject <string>("foo");
var values = new ConcurrentCountedSet <bool>();
System.Threading.Tasks.Parallel.For(0, 1000, i => values.Add(o.CompareAndSet(i % 2 == 0 ? "bar" : "foo", "bar")));
Assert.AreEqual(expected, values[true] + values[false]);
}
public void AtomicObjectGetAndSetReturnsOriginalValueMultiThreaded()
{
const int expected = 1000;
ConcurrentCountedSet <string> values = new ConcurrentCountedSet <string>();
var o = new AtomicObject <string>("foo");
System.Threading.Tasks.Parallel.For(0, 1000, i => values.Add(o.GetAndSet(i % 2 == 0 ? "bar" : "foo")));
Assert.AreEqual(expected, values["foo"] + values["bar"]);
}
public void ConcurrentCountedSetSupportsNonGenericIteration()
{
var set = new ConcurrentCountedSet <string>(new[] { "foo", "foo", "foo", "bar", "bar" });
Assert.DoesNotThrow(() =>
{
System.Collections.IEnumerator enumerator = (set as System.Collections.IEnumerable).GetEnumerator();
while (enumerator.MoveNext())
{
//ignore empty block
}
});
}
public void ConcurrentCountedSetSupportsGenericIteration()
{
var set = new ConcurrentCountedSet <string>(new[] { "foo", "foo", "foo", "bar", "bar" });
Assert.DoesNotThrow(() =>
{
IEnumerator <string> enumerator = set.GetEnumerator();
while (enumerator.MoveNext())
{
//ignore empty block
}
});
}
public void ConcurrentCountedSetSupportsNonGenericIterationForExpectedNumberOfElements()
{
const int expected = 2;
int count = 0;
var set = new ConcurrentCountedSet <string>(new[] { "foo", "foo", "foo", "bar", "bar" });
System.Collections.IEnumerator enumerator = (set as System.Collections.IEnumerable).GetEnumerator();
while (enumerator.MoveNext())
{
count++;
}
Assert.AreEqual(expected, count);
}
public void AtomicObjectGetAndSetReturnsOriginalValue()
{
const int expected = 1000;
ConcurrentCountedSet <string> values = new ConcurrentCountedSet <string>();
var o = new AtomicObject <string>("foo");
for (int i = 0; i < 1000; i++)
{
values.Add(o.GetAndSet(i % 2 == 0 ? "bar" : "foo"));
}
Assert.AreEqual(expected, values["foo"] + values["bar"]);
}
public void AtomicObjectCompareAndSetReturnsExpectedValuesForFailedMatches()
{
const int expected = 1000;
var o = new AtomicObject <string>("foo");
var values = new ConcurrentCountedSet <bool>();
for (int i = 0; i < 1000; i++)
{
values.Add(o.CompareAndSet(i % 2 == 0 ? "bar" : "foo", "bar"));
}
Assert.AreEqual(expected, values[true] + values[false]);
}
public void AtomicBooleanCompareAndSetReturnsExpectedValuesForFailedMatches()
{
const int expected = 1000;
var b = new AtomicBoolean(true);
var values = new ConcurrentCountedSet <bool>();
for (int i = 0; i < 1000; i++)
{
values.Add(b.CompareAndSet(i % 2 != 0, false));
}
Assert.AreEqual(expected, values[true] + values[false]);
}
public void AtomicBooleanGetAndSetReturnsOriginalValue()
{
const int expected = 1000;
ConcurrentCountedSet <bool> values = new ConcurrentCountedSet <bool>();
var b = new AtomicBoolean();
for (int i = 0; i < 1000; i++)
{
values.Add(b.GetAndSet(i % 2 == 0));
}
Assert.AreEqual(expected, values[true] + values[false]);
}
public void ConcurrentCountedSetRemovesItemOnceCountReducedToZeroMultiThreaded()
{
var set = new ConcurrentCountedSet <string>();
for (int i = 0; i < 1000; i++)
{
set.Add("bar");
}
System.Threading.Tasks.Parallel.For(0, 1000, i =>
{
set.Remove("bar");
});
Assert.IsFalse(set.Contains("bar"));
}
public void IfItemIsAddedToSetMultipleTimesRemoveReducesCountByOne()
{
int firstCount;
int secondCount;
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.Add("foo");
set.TryGetCount("foo", out firstCount);
set.Remove("foo");
set.TryGetCount("foo", out secondCount);
Assert.AreEqual(2, firstCount);
Assert.AreEqual(1, secondCount);
}
public void ConcurrentCountedSetMaintainsDistinctCountForDifferentItems()
{
int fooCount;
int barCount;
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.Add("foo");
set.Add("foo");
set.Add("bar");
set.Add("bar");
set.TryGetCount("foo", out fooCount);
set.TryGetCount("bar", out barCount);
Assert.AreEqual(3, fooCount);
Assert.AreEqual(2, barCount);
}
public void ConcurrentCountedSetMaintainsDistinctCountForDifferentItemsInLoop()
{
var set = new ConcurrentCountedSet <string>();
for (int i = 0; i < 1000; i++)
{
if (i % 2 == 0)
{
set.Add("foo");
}
else
{
set.Add("bar");
}
}
Assert.AreEqual(500, set["foo"]);
Assert.AreEqual(500, set["bar"]);
}
public void ConcurrentCountedSetMaintainsDistinctCountForDifferentItemsInLoopMultiThreaded()
{
var set = new ConcurrentCountedSet <string>();
System.Threading.Tasks.Parallel.For(0, 1000, i =>
{
if (i % 2 == 0)
{
set.Add("foo");
}
else
{
set.Add("bar");
}
});
Assert.AreEqual(500, set["foo"]);
Assert.AreEqual(500, set["bar"]);
}
public void ConcurrentCountedSetDoesNotRemoveItemIfCountIsGreaterThanZeroMultiThreaded()
{
const int expected = 1;
var set = new ConcurrentCountedSet <string>();
for (int i = 0; i < 1000; i++)
{
set.Add("bar");
}
System.Threading.Tasks.Parallel.For(0, 999, i =>
{
set.Remove("bar");
});
int currentCount;
Assert.IsTrue(set.TryGetCount("bar", out currentCount));
Assert.AreEqual(expected, currentCount);
}
public void ConcurrentCountedSetDoesNotRemoveItemIfCountIsGreaterThanZero()
{
const int expected = 1;
var set = new ConcurrentCountedSet <string>();
for (int i = 0; i < 1000; i++)
{
set.Add("bar");
}
for (int i = 0; i < 999; i++)
{
set.Remove("bar");
}
int currentCount;
Assert.IsTrue(set.TryGetCount("bar", out currentCount));
Assert.AreEqual(expected, currentCount);
}
public void ConcurrentCountedSetRemovesItemOnceCountReducedToZero()
{
int removeCount = 0;
var set = new ConcurrentCountedSet <string>();
for (int i = 0; i < 1000; i++)
{
set.Add("bar");
}
for (int i = 0; i < 1000; i++)
{
if (set.Remove("bar"))
{
removeCount = Interlocked.Increment(ref removeCount);
}
}
Assert.AreEqual(1000, removeCount);
Assert.IsFalse(set.Contains("bar"));
}
public void IfItemIsAddedToSetMutlipleTimesItMustBeRemovedAnEqualNumberOfTimes()
{
bool firstCheck;
bool secondCheck;
bool thirdCheck;
var set = new ConcurrentCountedSet <string>();
set.Add("foo");
set.Add("foo");
set.Add("foo");
set.Remove("foo");
firstCheck = set.Contains("foo");
set.Remove("foo");
secondCheck = set.Contains("foo");
set.Remove("foo");
thirdCheck = set.Contains("foo");
Assert.IsTrue(firstCheck);
Assert.IsTrue(secondCheck);
Assert.IsFalse(thirdCheck);
}
