public void Cancellation_after_two_items___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataForTrendAsync();
var expected = ExpectedForTrend().Take(2).ToList();
var cts = new CancellationTokenSource();
var actual = new List <DataPoint>();
int idx = 0;
Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
await foreach (DataPoint dp in sut.ProcessAsync(data).WithCancellation(cts.Token))
{
actual.Add(dp);
idx++;
if (idx == 2)
{
cts.Cancel();
}
}
});
CollectionAssert.AreEqual(expected, actual);
}
public async Task Cancellation___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataAsync(RawDataForTrend());
var expected = ExpectedForTrend().Take(2).ToList();
DataPointIterator dataPointIterator = sut.ProcessAsync(data);
var cts = new CancellationTokenSource();
var enumerator = dataPointIterator.GetAsyncEnumerator(cts.Token);
var actual = new List <DataPoint>();
await enumerator.MoveNextAsync();
actual.Add(enumerator.Current);
await enumerator.MoveNextAsync();
actual.Add(enumerator.Current);
cts.Cancel();
List <DataPoint> res = null;
Assert.ThrowsAsync <OperationCanceledException>(async() => res = await dataPointIterator.ToListAsync(cts.Token));
CollectionAssert.AreEqual(expected, actual);
Assert.IsNull(res);
}
public void Known_sequence___correct_result()
{
var sut = new SwingingDoorCompression(1);
var data = KnownSequence();
var iterator = sut.Process(data).GetEnumerator();
var expected = KnownSequenceExpected().ToArray();
Assert.Multiple(() =>
{
int step = 0;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
});
}
public void Cloning_iterates_over_fresh_set()
{
var sut = new SwingingDoorCompression(1);
var data = KnownSequence().ToArray().Select(dp => dp);
var expected = KnownSequence().ToArray();
var filter = sut.Process(data);
var iterator = filter.GetEnumerator();
iterator.MoveNext();
iterator = filter.Clone().GetEnumerator();
Assert.Multiple(() =>
{
int step = 0;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
step++;
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
});
}
public void Empty_Array___empty_result()
{
var sut = new SwingingDoorCompression(1);
var data = Array.Empty <DataPoint>();
var iterator = sut.Process(data).GetEnumerator();
Assert.IsFalse(iterator.MoveNext());
}
public void Empty_IEnumerable___empty_result()
{
var sut = new SwingingDoorCompression(1);
var data = Empty();
var iterator = sut.Process(data).GetEnumerator();
Assert.IsFalse(iterator.MoveNext());
}
public async Task Empty_IAsyncEnumerable___empty_result()
{
var sut = new SwingingDoorCompression(1);
var data = EmptyAsync();
var iterator = sut.ProcessAsync(data).GetAsyncEnumerator();
Assert.IsFalse(await iterator.MoveNextAsync());
}
public void Indexed_MoveNext_without_GetEnumerator___throws_InvalidOperation()
{
var sut = new SwingingDoorCompression(1);
var data = RawDataForTrend().ToArray();
var iterator = sut.Process(data);
Assert.Throws <InvalidOperationException>(() => iterator.MoveNext());
}
public async Task Empty_IAsyncEnumerable___empty_result()
{
var sut = new SwingingDoorCompression(1d);
var data = EmptyAsync();
var actual = sut.ProcessAsync(data);
Assert.AreEqual(0, (await actual.ToListAsync()).Count);
}
//-----------------------------------------------------------------
public EnumerableIterator(
SwingingDoorCompression swingingDoorCompression,
IEnumerable <DataPoint> source,
IEnumerator <DataPoint> enumerator)
: base(swingingDoorCompression)
{
_source = source;
_enumerator = enumerator;
}
public void Data_given_as_ListWrapper___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = new ListWrapper <DataPoint>(RawDataForTrend().ToList());
var expected = ExpectedForTrend().ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Empty_Array___empty_result()
{
var sut = new SwingingDoorCompression(1d);
var data = new DataPoint[0];
var actual = sut.Process(data);
Assert.AreSame(Array.Empty <DataPoint>(), actual.ToArray());
Assert.AreEqual(0, actual.ToList().Count);
}
public void Data_given_as_IList___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataForTrend().ToList().AsReadOnly();
var expected = ExpectedForTrend().ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_given_as_IAsyncEnumerable___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataForTrendAsync();
var expected = ExpectedForTrend().ToList();
var actual = await sut.ProcessAsync(data).ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_given_as_IAsyncEnumerable___OK(double compressionDeviation, IAsyncEnumerable <DataPoint> rawData, IEnumerable <DataPoint> expectedData)
{
var sut = new SwingingDoorCompression(compressionDeviation);
var data = rawData;
var expected = expectedData.ToList();
var actual = await sut.ProcessAsync(data).ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_IAsyncEnumerable_with_maxDeltaX___OK()
{
var sut = new SwingingDoorCompression(1d, 6d);
var data = RawDataAsync(RawDataForMaxDelta());
var expected = ExpectedForMaxDelta().ToList();
var actual = await sut.ProcessAsync(data).ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public void Data_IList_with_maxDeltaX___OK()
{
var sut = new SwingingDoorCompression(1d, 6d);
var data = RawDataForMaxDelta().ToList().AsReadOnly();
var expected = ExpectedForMaxDelta().ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void One_DataPoint_IEnumerable___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataForMaxDelta().Take(1);
var expected = RawDataForMaxDelta().Take(1).ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoint_IList___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataForMaxDelta().Take(2).ToList().AsReadOnly();
var expected = RawDataForMaxDelta().Take(2).ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void MinDeltaX_IList___OK()
{
var sut = new SwingingDoorCompression(1d, minDeltaX: 1d);
var data = RawMinDeltaX().ToList().AsReadOnly();
var expected = ExpectedMinDeltaX().ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void CompressionDeviation_0_as_array___input_echoed()
{
var sut = new SwingingDoorCompression(0);
var data = KnownSequence().ToArray();
var result = sut.Process(data);
var expected = KnownSequence().ToArray();
var actual = result.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Known_sequence_with_constant_part_ToArray____correct_result()
{
var sut = new SwingingDoorCompression(1);
var data = KnownSequenceWithConstantPart();
var result = sut.Process(data);
var expected = KnownSequenceWithConstantPartExpected().ToArray();
var actual = result.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Data_List_with_maxDeltaX___OK()
{
var sut = new SwingingDoorCompression(1d, 6d);
var data = RawDataForMaxDelta().ToList();
var expected = ExpectedForMaxDelta().ToList();
var actual = sut.Process(data).ToList();
Print(expected, "expected");
Print(actual, "actual");
CollectionAssert.AreEqual(expected, actual);
}
public void Data_given_as_IList___OK(double compressionDeviation, IEnumerable <DataPoint> rawData, IEnumerable <DataPoint> expectedData)
{
var sut = new SwingingDoorCompression(compressionDeviation);
var data = rawData.ToList().AsReadOnly();
var expected = expectedData.ToList();
var actual = sut.Process(data).ToList();
Print(expected, "expected");
Print(actual, "actual");
CollectionAssert.AreEqual(expected, actual);
}
public void MinDeltaX_List___OK()
{
var sut = new SwingingDoorCompression(1d, minDeltaX: 1d);
var data = RawMinDeltaX().ToList();
var expected = ExpectedMinDeltaX().ToList();
var actual = sut.Process(data).ToList();
Print(expected, "expected");
Print(actual, "actual");
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoints_IEnumerable___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = RawDataForMaxDelta().Take(2);
var expected = RawDataForMaxDelta().Take(2).ToList();
var actual = sut.Process(data).ToList();
Print(expected, "expected");
Print(actual, "actual");
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_IAsyncEnumerable_with_minDeltaX_ToArray___OK()
{
int currentRawMinDeltaXCount = RawMinDeltaXCounter;
var sut = new SwingingDoorCompression(1d, minDeltaX: 1d);
var data = RawMinDeltaXAsync();
var expected = ExpectedMinDeltaX().ToList();
var actual = await sut.ProcessAsync(data).ToArrayAsync();
CollectionAssert.AreEqual(expected, actual);
Assert.AreEqual(currentRawMinDeltaXCount + 1, RawMinDeltaXCounter);
}
public void Empty_IList___OK()
{
var sut = new SwingingDoorCompression(1d);
var data = KnownSequence().Take(0).ToList().AsReadOnly();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
Assert.AreEqual(0, actual.Count);
}
public void Empty_IEnumerable_foreach___empty_result()
{
var sut = new SwingingDoorCompression(1);
var data = Empty();
int count = 0;
foreach (DataPoint dp in sut.Process(data))
{
count++;
}
Assert.AreEqual(0, count);
}
public async Task Empty_IAsyncEnumerable_foreach___empty_result()
{
var sut = new SwingingDoorCompression(1);
var data = EmptyAsync();
int count = 0;
await foreach (DataPoint db in sut.ProcessAsync(data))
{
count++;
}
Assert.AreEqual(0, count);
}
