public void Known_sequence___correct_result()
{
var sut = new DeadBandCompression(0.1);
var data = KnownSequence();
var iterator = sut.Process(data).GetEnumerator();
var expected = KnownSequenceExpected(swingingDoor: false).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.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 Cancellation_after_two_items___OK()
{
var sut = new DeadBandCompression(0.1);
var data = KnownSequenceAsync();
var expected = KnownSequence().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(actual, expected);
}
public void Cloning_iterates_over_fresh_set()
{
var sut = new DeadBandCompression(0.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 async Task Cancellation___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrendAsync();
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 Empty_Array___empty_result()
{
var sut = new DeadBandCompression(0.1);
var data = Array.Empty <DataPoint>();
var iterator = sut.Process(data).GetEnumerator();
Assert.IsFalse(iterator.MoveNext());
}
public async Task Empty_IAsyncEnumerable___empty_result()
{
var sut = new DeadBandCompression(0.1);
var data = EmptyAsync();
var iterator = sut.ProcessAsync(data).GetAsyncEnumerator();
Assert.IsFalse(await iterator.MoveNextAsync());
}
public void Empty_IEnumerable___empty_result()
{
var sut = new DeadBandCompression(0.1);
var data = Empty();
var iterator = sut.Process(data).GetEnumerator();
Assert.IsFalse(iterator.MoveNext());
}
public async Task Empty_IAsyncEnumerable___empty_result()
{
var sut = new DeadBandCompression(0.1);
var data = EmptyAsync();
var actual = sut.ProcessAsync(data);
Assert.AreEqual(0, (await actual.ToListAsync()).Count);
}
public void Indexed_MoveNext_without_GetEnumerator___throws_InvalidOperation()
{
var sut = new DeadBandCompression(1);
var data = RawDataForTrend().ToArray();
var iterator = sut.Process(data);
Assert.Throws <InvalidOperationException>(() => iterator.MoveNext());
}
public async Task Data_IAsyncEnumerable_with_maxDeltaX___OK()
{
var sut = new DeadBandCompression(0.1, 4d);
var data = RawDataForMaxDeltaAsync();
var expected = ExpectedForMaxDelta().ToList();
var actual = await sut.ProcessAsync(data).ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public async Task Data_given_as_IAsyncEnumerable___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrendAsync();
var expected = ExpectedForTrend().ToList();
var actual = await sut.ProcessAsync(data).ToListAsync();
CollectionAssert.AreEqual(expected, actual);
}
public void KnownData_given_as_IEnumerable___OK()
{
var sut = new DeadBandCompression(0.1);
var data = KnownSequence();
var expected = KnownSequence().ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Data_given_as_ArrayWrapper___OK()
{
var sut = new DeadBandCompression(0.1);
var data = new ArrayWrapper <DataPoint>(RawDataForTrend().ToArray());
var expected = ExpectedForTrend().ToArray();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoint_IEnumerable___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForMaxDelta().Take(2);
var expected = RawDataForMaxDelta().Take(2).ToList();
var actual = sut.Process(data).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Data_given_as_IEnumerable___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrend();
var expected = ExpectedForTrend().ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void One_DataPoint_List___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForMaxDelta().Take(1).ToList();
var expected = RawDataForMaxDelta().Take(1).ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void Data_IList_with_maxDeltaX___OK()
{
var sut = new DeadBandCompression(0.1, 4d);
var data = RawDataForMaxDelta().ToList().AsReadOnly();
var expected = ExpectedForMaxDelta().ToList();
var actual = sut.Process(data).ToList();
CollectionAssert.AreEqual(expected, actual);
}
public void Empty_Array___empty_result()
{
var sut = new DeadBandCompression(0.1);
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 InstrumentPrecision_0_as_array___input_echoed()
{
var sut = new DeadBandCompression(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 DeadBandCompression(0.1);
var data = KnownSequenceWithConstantPart();
var result = sut.Process(data);
var expected = KnownSequenceWithConstantPartExpected(swingingDoor: false).ToArray();
var actual = result.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Empty_IEnumerable_foreach___empty_result()
{
var sut = new DeadBandCompression(0.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 DeadBandCompression(0.1);
var data = EmptyAsync();
int count = 0;
await foreach (DataPoint db in sut.ProcessAsync(data))
{
count++;
}
Assert.AreEqual(0, count);
}
public void Two_DataPoints_IList___OK(IEnumerable <DataPoint> rawData, List <DataPoint> expectedData)
{
var sut = new DeadBandCompression(0.1);
var data = rawData.ToList().AsReadOnly();
var expected = expectedData;
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void InstrumentPrecision_0_as_array_foreach___input_echoed()
{
var sut = new DeadBandCompression(0);
var data = KnownSequence().ToArray();
var result = sut.Process(data);
var expected = KnownSequence().ToArray();
var actual = new List <DataPoint>();
foreach (DataPoint dp in result)
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Known_sequence_with_constant_part_foreach____correct_result()
{
var sut = new DeadBandCompression(0.1);
var data = KnownSequenceWithConstantPart();
var result = sut.Process(data);
var expected = KnownSequenceWithConstantPartExpected(swingingDoor: false).ToArray();
var actual = new List <DataPoint>();
foreach (DataPoint dp in result)
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Data_List_with_maxDeltaX___OK()
{
var sut = new DeadBandCompression(0.1, 4d);
var data = RawDataForMaxDelta().ToList();
var expected = ExpectedForMaxDelta().ToList();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public async Task Known_sequence_foreach___correct_result()
{
var sut = new DeadBandCompression(0.1);
var data = KnownSequenceAsync();
var result = sut.ProcessAsync(data);
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
var actual = new List <DataPoint>();
await foreach (DataPoint dp in result)
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoint_List___OK()
{
var sut = new DeadBandCompression(0.1);
var data = KnownSequence().Take(2).ToList();
var expected = KnownSequence().Take(2).ToList();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Two_DataPoint_IList___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForMaxDelta().Take(2).ToList().AsReadOnly();
var expected = RawDataForMaxDelta().Take(2).ToList();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}
public void Data_given_as_IList___OK()
{
var sut = new DeadBandCompression(0.1);
var data = RawDataForTrend().ToList().AsReadOnly();
var expected = ExpectedForTrend().ToList();
var actual = new List <DataPoint>();
foreach (DataPoint dp in sut.Process(data))
{
actual.Add(dp);
}
CollectionAssert.AreEqual(expected, actual);
}