Skip to content

Commit d2faa38

Browse files
gfoidlgfoidl
authored
Fixed DataPointIndexedIterator BuildCollection + more tests (#58)
1 parent b742427 commit d2faa38

File tree

11 files changed

+322
-47
lines changed

11 files changed

+322
-47
lines changed

‎source/gfoidl.DataCompression/DataPointIndexedIterator.cs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// (c) gfoidl, all rights reserved
1+
// (c) gfoidl, all rights reserved
22

33
using System.Collections.Generic;
44
using System.Diagnostics;
@@ -205,18 +205,18 @@ private void BuildCollection<TBuilder>(TList source, ref TBuilder builder)
205205
continue;
206206
}
207207

208-
if (!archive.MaxDelta && (uint)snapShotIndex < (uint)source.Count)
208+
if (!archive.MaxDelta && _lastArchivedIndex != snapShotIndex && (uint)snapShotIndex < (uint)source.Count)
209209
{
210210
DataPoint snapShot = source[snapShotIndex];
211+
_lastArchived = snapShot;
211212
builder.Add(snapShot);
212-
_lastArchived = snapShot;
213213
}
214214

215215
incomingIndex = this.HandleSkipMinDeltaX(source, incomingIndex, snapShotIndex);
216216

217217
incoming = source[incomingIndex];
218-
builder.Add(incoming);
219218
_lastArchived = incoming;
219+
builder.Add(incoming);
220220
this.Init(incomingIndex, incoming, ref snapShotIndex);
221221

222222
incomingIndex++;

‎tests/gfoidl.DataCompression.Tests/Compression/Base.cs‎

Lines changed: 50 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// (c) gfoidl, all rights reserved
1+
// (c) gfoidl, all rights reserved
22

33
using System.Collections.Generic;
44
using NUnit.Framework;
@@ -18,10 +18,52 @@ protected static IEnumerable<DataPoint> Empty()
1818
}
1919
//---------------------------------------------------------------------
2020
protected static IEnumerable<DataPoint> KnownSequence()
21+
{
22+
yield return (0, 1);
23+
yield return (1, 2);
24+
yield return (2, 2);
25+
yield return (3, -1);
26+
yield return (4, 3);
27+
}
28+
//---------------------------------------------------------------------
29+
protected static IEnumerable<DataPoint> KnownSequenceExpected(bool swingingDoor = true)
2130
{
2231
yield return (0, 1);
23-
yield return (1, 2);
24-
yield return (2, -1);
32+
33+
if (!swingingDoor)
34+
{
35+
yield return (1, 2);
36+
}
37+
38+
yield return (2, 2);
39+
yield return (3, -1);
40+
yield return (4, 3);
41+
}
42+
//---------------------------------------------------------------------
43+
protected static IEnumerable<DataPoint> KnownSequenceWithConstantPart()
44+
{
45+
yield return (0, 0);
46+
yield return (1, 1);
47+
yield return (2, 1);
48+
yield return (3, 1);
49+
yield return (4, 1);
50+
yield return (5, 1);
51+
yield return (6, -1);
52+
yield return (7, 4);
53+
}
54+
//---------------------------------------------------------------------
55+
protected static IEnumerable<DataPoint> KnownSequenceWithConstantPartExpected(bool swingingDoor = true)
56+
{
57+
yield return (0, 0);
58+
59+
if (!swingingDoor)
60+
{
61+
yield return (1, 1);
62+
}
63+
64+
yield return (5, 1);
65+
yield return (6, -1);
66+
yield return (7, 4);
2567
}
2668
//---------------------------------------------------------------------
2769
#if NETCOREAPP
@@ -38,7 +80,11 @@ protected static async IAsyncEnumerable<DataPoint> KnownSequenceAsync()
3880
await Task.Yield();
3981
yield return (1, 2);
4082
await Task.Yield();
41-
yield return (2, -1);
83+
yield return (2, 2);
84+
await Task.Yield();
85+
yield return (3, -1);
86+
await Task.Yield();
87+
yield return (4, 3);
4288
}
4389
#endif
4490
}

‎tests/gfoidl.DataCompression.Tests/Compression/DeadBandCompressionTests/Clone.cs‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// (c) gfoidl, all rights reserved
1+
// (c) gfoidl, all rights reserved
22

33
using System.Linq;
44
using NUnit.Framework;
@@ -12,7 +12,7 @@ public void Cloning_iterates_over_fresh_set()
1212
{
1313
var sut = new DeadBandCompression(0.1);
1414
var data = KnownSequence().ToArray().Select(dp => dp);
15-
var expected = KnownSequence().ToArray();
15+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
1616
var filter = sut.Process(data);
1717

1818
var iterator = filter.GetEnumerator();
@@ -32,6 +32,12 @@ public void Cloning_iterates_over_fresh_set()
3232
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
3333
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
3434
step++;
35+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
36+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
37+
step++;
38+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
39+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
40+
step++;
3541
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
3642
});
3743
}

‎tests/gfoidl.DataCompression.Tests/Compression/DeadBandCompressionTests/MoveNext.cs‎

Lines changed: 99 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// (c) gfoidl, all rights reserved
1+
// (c) gfoidl, all rights reserved
22

33
using System;
44
using System.Collections.Generic;
@@ -60,7 +60,7 @@ public void Empty_IEnumerable_foreach___empty_result()
6060
public void Empty_Array___empty_result()
6161
{
6262
var sut = new DeadBandCompression(0.1);
63-
var data = new DataPoint[0];
63+
var data = Array.Empty<DataPoint>();
6464
var iterator = sut.Process(data).GetEnumerator();
6565

6666
Assert.IsFalse(iterator.MoveNext());
@@ -72,7 +72,7 @@ public void Known_sequence___correct_result()
7272
var sut = new DeadBandCompression(0.1);
7373
var data = KnownSequence();
7474
var iterator = sut.Process(data).GetEnumerator();
75-
var expected = KnownSequence().ToArray();
75+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
7676

7777
Assert.Multiple(() =>
7878
{
@@ -86,6 +86,12 @@ public void Known_sequence___correct_result()
8686
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
8787
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
8888
step++;
89+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
90+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
91+
step++;
92+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
93+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
94+
step++;
8995
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
9096
});
9197
}
@@ -96,7 +102,7 @@ public void Known_sequence_as_array___correct_result()
96102
var sut = new DeadBandCompression(0.1);
97103
var data = KnownSequence().ToArray();
98104
var iterator = sut.Process(data).GetEnumerator();
99-
var expected = KnownSequence().ToArray();
105+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
100106

101107
Assert.Multiple(() =>
102108
{
@@ -110,6 +116,12 @@ public void Known_sequence_as_array___correct_result()
110116
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
111117
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
112118
step++;
119+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
120+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
121+
step++;
122+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
123+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
124+
step++;
113125
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
114126
});
115127
}
@@ -120,7 +132,7 @@ public void Known_sequence_foreach___correct_result()
120132
var sut = new DeadBandCompression(0.1);
121133
var data = KnownSequence();
122134
var result = sut.Process(data);
123-
var expected = KnownSequence().ToList();
135+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
124136
var actual = new List<DataPoint>();
125137

126138
foreach (DataPoint dp in result)
@@ -135,6 +147,88 @@ public void Known_sequence_as_array_foreach___correct_result()
135147
var sut = new DeadBandCompression(0.1);
136148
var data = KnownSequence().ToArray();
137149
var result = sut.Process(data);
150+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
151+
var actual = new List<DataPoint>();
152+
153+
foreach (DataPoint dp in result)
154+
actual.Add(dp);
155+
156+
CollectionAssert.AreEqual(expected, actual);
157+
}
158+
//---------------------------------------------------------------------
159+
[Test]
160+
public void Known_sequence_ToArray___correct_result()
161+
{
162+
var sut = new DeadBandCompression(0.1);
163+
var data = KnownSequence();
164+
var result = sut.Process(data);
165+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
166+
167+
var actual = result.ToArray();
168+
169+
CollectionAssert.AreEqual(expected, actual);
170+
}
171+
//---------------------------------------------------------------------
172+
[Test]
173+
public void Known_sequence_with_constant_part_foreach____correct_result()
174+
{
175+
var sut = new DeadBandCompression(0.1);
176+
var data = KnownSequenceWithConstantPart();
177+
var result = sut.Process(data);
178+
var expected = KnownSequenceWithConstantPartExpected(swingingDoor: false).ToArray();
179+
var actual = new List<DataPoint>();
180+
181+
foreach (DataPoint dp in result)
182+
actual.Add(dp);
183+
184+
CollectionAssert.AreEqual(expected, actual);
185+
}
186+
//---------------------------------------------------------------------
187+
[Test]
188+
public void Known_sequence_with_constant_part_ToArray____correct_result()
189+
{
190+
var sut = new DeadBandCompression(0.1);
191+
var data = KnownSequenceWithConstantPart();
192+
var result = sut.Process(data);
193+
var expected = KnownSequenceWithConstantPartExpected(swingingDoor: false).ToArray();
194+
195+
var actual = result.ToArray();
196+
197+
CollectionAssert.AreEqual(expected, actual);
198+
}
199+
//---------------------------------------------------------------------
200+
[Test]
201+
public void InstrumentPrecision_0___input_echoed()
202+
{
203+
var sut = new DeadBandCompression(0);
204+
var data = KnownSequence();
205+
var result = sut.Process(data);
206+
var expected = KnownSequence().ToArray();
207+
208+
var actual = result.ToArray();
209+
210+
CollectionAssert.AreEqual(expected, actual);
211+
}
212+
//---------------------------------------------------------------------
213+
[Test]
214+
public void InstrumentPrecision_0_as_array___input_echoed()
215+
{
216+
var sut = new DeadBandCompression(0);
217+
var data = KnownSequence().ToArray();
218+
var result = sut.Process(data);
219+
var expected = KnownSequence().ToArray();
220+
221+
var actual = result.ToArray();
222+
223+
CollectionAssert.AreEqual(expected, actual);
224+
}
225+
//---------------------------------------------------------------------
226+
[Test]
227+
public void InstrumentPrecision_0_as_array_foreach___input_echoed()
228+
{
229+
var sut = new DeadBandCompression(0);
230+
var data = KnownSequence().ToArray();
231+
var result = sut.Process(data);
138232
var expected = KnownSequence().ToArray();
139233
var actual = new List<DataPoint>();
140234

‎tests/gfoidl.DataCompression.Tests/Compression/DeadBandCompressionTests/MoveNextAsync.cs‎

Lines changed: 21 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
1-
// (c) gfoidl, all rights reserved
1+
// (c) gfoidl, all rights reserved
22

3-
using System;
43
using System.Collections.Generic;
4+
using System.Linq;
55
using System.Threading.Tasks;
66
using NUnit.Framework;
77

@@ -35,15 +35,12 @@ public async Task Empty_IAsyncEnumerable_foreach___empty_result()
3535
}
3636
//---------------------------------------------------------------------
3737
[Test]
38-
public async Task Known_sequence___correct_result()
38+
public void Known_sequence___correct_result()
3939
{
4040
var sut = new DeadBandCompression(0.1);
4141
var data = KnownSequenceAsync();
4242
var iterator = sut.ProcessAsync(data).GetAsyncEnumerator();
43-
var expected = new List<DataPoint>();
44-
45-
await foreach (DataPoint dp in KnownSequenceAsync())
46-
expected.Add(dp);
43+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
4744

4845
Assert.Multiple(async () =>
4946
{
@@ -53,6 +50,8 @@ public async Task Known_sequence___correct_result()
5350
Assert.AreEqual(expected[1], iterator.Current);
5451
await iterator.MoveNextAsync();
5552
Assert.AreEqual(expected[2], iterator.Current);
53+
await iterator.MoveNextAsync();
54+
Assert.AreEqual(expected[3], iterator.Current);
5655
});
5756
}
5857
//---------------------------------------------------------------------
@@ -62,11 +61,23 @@ public async Task Known_sequence_foreach___correct_result()
6261
var sut = new DeadBandCompression(0.1);
6362
var data = KnownSequenceAsync();
6463
var result = sut.ProcessAsync(data);
65-
var expected = new List<DataPoint>();
64+
var expected = KnownSequenceExpected(swingingDoor: false).ToArray();
6665
var actual = new List<DataPoint>();
6766

68-
await foreach (DataPoint dp in KnownSequenceAsync())
69-
expected.Add(dp);
67+
await foreach (DataPoint dp in result)
68+
actual.Add(dp);
69+
70+
CollectionAssert.AreEqual(expected, actual);
71+
}
72+
//---------------------------------------------------------------------
73+
[Test]
74+
public async Task InstrumentPrecision_0___input_echoed()
75+
{
76+
var sut = new DeadBandCompression(0);
77+
var data = KnownSequenceAsync();
78+
var result = sut.ProcessAsync(data);
79+
var expected = KnownSequence().ToArray();
80+
var actual = new List<DataPoint>();
7081

7182
await foreach (DataPoint dp in result)
7283
actual.Add(dp);

‎tests/gfoidl.DataCompression.Tests/Compression/NoCompressionTests/Clone.cs‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// (c) gfoidl, all rights reserved
1+
// (c) gfoidl, all rights reserved
22

33
using System.Linq;
44
using NUnit.Framework;
@@ -32,6 +32,12 @@ public void Cloning_iterates_over_fresh_set()
3232
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
3333
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
3434
step++;
35+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
36+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
37+
step++;
38+
Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}");
39+
Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}");
40+
step++;
3541
Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}");
3642
});
3743
}

0 commit comments

Comments
 (0)