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); }