public static void RemoveStressTest(IProducerConsumerCollection<int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate
{
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
while (!coll.TryAdd(i)) ;
bool state = true;
Assert.AreEqual((count + delta) * threads, coll.Count, "#0");
ParallelTestHelper.ParallelStressTest(coll, (q) =>
{
bool s = true;
int t;
for (int i = 0; i < count; i++)
{
s &= coll.TryTake(out t);
// try again in case it was a transient failure
if (!s && coll.TryTake(out t))
s = true;
}
if (!s)
state = false;
}, threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake(out temp))
{
actual += temp.ToString(); ;
}
IEnumerable<int> range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
range = range.Reverse();
string expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
actual.AreCollectionEquivalent(expected, "#3");
//--TODO Assert.That (actual, new CollectionEquivalentConstraint (expected), "#3");
}
else
Assert.AreEqual(expected, actual, "#3");
}, 10);
}
public static void RemoveStress(this IProducerConsumerCollection <int> coll, CheckOrderingType order)
{
ParallelTestTool.Repeat(() => {
const int count = 10;
const int threads = 5;
const int delta = 5;
const int totalCount = (count + delta) * threads;
for (var i = 0; i < totalCount; i++)
{
coll.TryAdd(i);
}
var state = true;
ParallelTestTool.ParallelStressTest(coll,
q => {
int t;
for (var i = 0; i < count; i++)
{
state &= q.TryTake(out t);
}
},
threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
var builder = new StringBuilder();
int temp;
while (coll.TryTake(out temp))
{
builder.Append(temp);
}
var actual = builder.ToString();
var range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads,
delta * threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
var expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
CollectionAssert.AreEquivalent(expected, actual, "#3");
}
else
{
Assert.AreEqual(expected, actual, "#3");
}
});
}
public static void RemoveStressTest(IProducerConsumerCollection <int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate {
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
{
coll.TryAdd(i);
}
bool state = true;
ParallelTestHelper.ParallelStressTest(coll, (q) => {
int t;
for (int i = 0; i < count; i++)
{
state &= coll.TryTake(out t);
}
}, threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake(out temp))
{
actual += temp.ToString();;
}
IEnumerable <int> range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
string expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
CollectionAssert.AreEquivalent(expected, actual, "#3");
}
else
{
Assert.AreEqual(expected, actual, "#3");
}
});
}
public static void RemoveStress(this IProducerConsumerCollection<int> coll, CheckOrderingType order) {
ParallelTestTool.Repeat(() => {
const int count = 10;
const int threads = 5;
const int delta = 5;
const int totalCount = (count + delta) * threads;
for(var i = 0; i < totalCount; i++)
coll.TryAdd(i);
var state = true;
ParallelTestTool.ParallelStressTest(coll,
q => {
int t;
for(var i = 0; i < count; i++)
state &= q.TryTake(out t);
},
threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
var builder = new StringBuilder();
int temp;
while(coll.TryTake(out temp)) {
builder.Append(temp);
}
var actual = builder.ToString();
var range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads,
delta * threads);
if(order == CheckOrderingType.Reversed)
range = range.Reverse();
var expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if(order == CheckOrderingType.DontCare)
CollectionAssert.AreEquivalent(expected, actual, "#3");
else
Assert.AreEqual(expected, actual, "#3");
});
}
public static void RemoveStressTest (IProducerConsumerCollection<int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat (delegate {
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
coll.TryAdd (i);
bool state = true;
ParallelTestHelper.ParallelStressTest (coll, (q) => {
int t;
for (int i = 0; i < count; i++)
state &= coll.TryTake (out t);
}, threads);
Assert.IsTrue (state, "#1");
Assert.AreEqual (delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake (out temp)) {
actual += temp.ToString ();;
}
IEnumerable<int> range = Enumerable.Range (order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
range = range.Reverse ();
string expected = range.Aggregate (string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
CollectionAssert.AreEquivalent (expected, actual, "#3");
else
Assert.AreEqual (expected, actual, "#3");
});
}
public static void RemoveStressTest(IProducerConsumerCollection <int> collection, CheckOrderingType order)
{
ParallelTestHelper.Repeat
(
() =>
{
const int count = 10;
const int threads = 5;
const int delta = 5;
for (var i = 0; i < (count + delta) * threads; i++)
{
while (!collection.TryAdd(i))
{
// Empty
}
}
var state = true;
Assert.AreEqual((count + delta) * threads, collection.Count, "#0");
ParallelTestHelper.ParallelStressTest
(
() =>
{
var check = true;
for (var i = 0; i < count; i++)
{
check &= collection.TryTake(out _);
// try again in case it was a transient failure
if (!check && collection.TryTake(out _))
{
check = true;
}
}
state &= check;
},
threads
);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, collection.Count, "#2");
var actual = string.Empty;
var builder = new StringBuilder();
builder.Append(actual);
while (collection.TryTake(out var temp))
{
builder.Append(temp.ToString());
}
actual = builder.ToString();
var range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
var expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DoNotCare)
{
Assert.That(actual, new CollectionEquivalentConstraint(expected), "#3");
}
else
{
Assert.AreEqual(expected, actual, "#3");
}
}, 10);
}
public static void RemoveStressTest(IProducerConsumerCollection <int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate
{
const int Count = 10;
const int Threads = 5;
const int Delta = 5;
for (var i = 0; i < (Count + Delta) * Threads; i++)
{
while (!coll.TryAdd(i))
{
}
}
var state = true;
Assert.AreEqual((Count + Delta) * Threads, coll.Count, "#0");
ParallelTestHelper.ParallelStressTest(coll, (q) =>
{
var s = true;
int t;
for (var i = 0; i < Count; i++)
{
s &= coll.TryTake(out t);
// try again in case it was a transient failure
if (!s && coll.TryTake(out t))
{
s = true;
}
}
state &= s;
}, Threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(Delta * Threads, coll.Count, "#2");
var actual = string.Empty;
int temp;
var builder = new StringBuilder();
builder.Append(actual);
while (coll.TryTake(out temp))
{
builder.Append(temp.ToString());
}
actual = builder.ToString();
var range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : Count * Threads, Delta * Threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
var expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
Assert.That(actual, new CollectionEquivalentConstraint(expected), "#3");
}
else
{
Assert.AreEqual(expected, actual, "#3");
}
}, 10);
}
public static void RemoveStressTest(IProducerConsumerCollection <int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate
{
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
{
while (!coll.TryAdd(i))
{
;
}
}
bool state = true;
Assert.AreEqual((count + delta) * threads, coll.Count, "#0");
ParallelTestHelper.ParallelStressTest(coll, (q) =>
{
bool s = true;
int t;
for (int i = 0; i < count; i++)
{
s &= coll.TryTake(out t);
// try again in case it was a transient failure
if (!s && coll.TryTake(out t))
{
s = true;
}
}
if (!s)
{
state = false;
}
}, threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake(out temp))
{
actual += temp.ToString();;
}
IEnumerable <int> range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
string expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
actual.AreCollectionEquivalent(expected, "#3");
//--TODO Assert.That (actual, new CollectionEquivalentConstraint (expected), "#3");
}
else
{
Assert.AreEqual(expected, actual, "#3");
}
}, 10);
}
