byteio - endian_test.go
1 package byteio
2
3 import (
4 "iter"
5 "math"
6 "testing"
7 )
8
9 type readWrite[T any] struct {
10 read func(StickyEndianReader) T
11 write func(StickyEndianWriter, T)
12 }
13
14 var (
15 testUints = [][]uint64{
16 {0x00, 0x01, 0x0f, 0x10, 0x1f, 0x20, 0x3f, 0x41, 0x7f, 0x80, 0xff},
17 {0x0100, 0x7fff, 0x8000, 0xffff},
18 {0x010000, 0x7fffff, 0x800000, 0xffffff},
19 {0x01000000, 0x7fffffff, 0x80000000, 0xffffffff},
20 {0x0100000000, 0x7fffffffff, 0x8000000000, 0xffffffffff},
21 {0x010000000000, 0x7fffffffffff, 0x800000000000, 0xffffffffffff},
22 {0x01000000000000, 0x7fffffffffffff, 0x80000000000000, 0xffffffffffffff},
23 {0x0100000000000000, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff},
24 }
25 testInts = [][]int64{
26 {-0x80, -0x40, -0x01, 0x00, 0x01, 0x7f, 0x10, 0x1f, 0x20, 0x3f, 0x40, 0x7f},
27 {-0x8000, -0x00ff, -0x0081, -0x0080, 0x0100, 0x7fff},
28 {-0x800000, -0x00ffff, -0x008001, -0x008000, 0x010000, 0x7fffff},
29 {-0x80000000, -0x00ffffff, -0x00800001, -0x00800000, 0x01000000, 0x7fffffff},
30 {-0x8000000000, -0x00ffffffff, -0x0080000001, -0x0080000000, 0x0100000000, 0x7fffffffff},
31 {-0x800000000000, -0x00ffffffffff, -0x008000000001, -0x008000000000, 0x010000000000, 0x7fffffffffff},
32 {-0x80000000000000, -0x00ffffffffffff, -0x00800000000001, -0x00800000000000, 0x01000000000000, 0x7fffffffffffff},
33 {-0x8000000000000000, -0x00ffffffffffffff, -0x0080000000000001, -0x0080000000000000, 0x0100000000000000, 0x7fffffffffffffff},
34 }
35 testFloats = [][]float64{
36 {0, 1, float64(math.Float32frombits(0x01)), float64(math.Float32frombits(0xff)), float64(math.Float32frombits(0xffffff)), float64(math.Float32frombits(0x80000000))},
37 {math.Float64frombits(0xffffffffffffff), math.Float64frombits(0x8000000000000000), math.Float64frombits(0x0101010101010101)},
38 }
39 testBytes = []byte{1, 2, 3, 4, 5, 6, 7, 8}
40 )
41
42 type testStickyReadWrite struct {
43 StickyEndianReader
44 StickyEndianWriter
45 }
46
47 func testEndians(buf *MemLittleEndian) iter.Seq2[string, testStickyReadWrite] {
48 return func(yield func(string, testStickyReadWrite) bool) {
49 _ = yield("Little", testStickyReadWrite{
50 &StickyReader{Reader: &LittleEndianReader{Reader: buf}},
51 &StickyWriter{Writer: &LittleEndianWriter{Writer: buf}},
52 }) && yield("Big", testStickyReadWrite{
53 &StickyReader{Reader: &BigEndianReader{Reader: buf}},
54 &StickyWriter{Writer: &BigEndianWriter{Writer: buf}},
55 }) && yield("StickyLittle", testStickyReadWrite{
56 &StickyLittleEndianReader{Reader: buf},
57 &StickyLittleEndianWriter{Writer: buf},
58 }) && yield("StickyBig", testStickyReadWrite{
59 &StickyBigEndianReader{Reader: buf},
60 &StickyBigEndianWriter{Writer: buf},
61 }) && yield("MemBig", testStickyReadWrite{
62 (*MemBigEndian)(buf),
63 (*MemBigEndian)(buf),
64 }) && yield("MemLittle", testStickyReadWrite{
65 buf,
66 buf,
67 })
68 }
69 }
70
71 func isMem(t testStickyReadWrite) bool {
72 if _, ok := t.StickyEndianReader.(*MemLittleEndian); ok {
73 return true
74 }
75
76 _, ok := t.StickyEndianReader.(*MemBigEndian)
77
78 return ok
79 }
80
81 func testReadWrite[T comparable](t *testing.T, tname string, numBytes int, rw readWrite[T], tests [][]T, expectedLittle, expectedBig T) {
82 t.Helper()
83
84 var buf MemLittleEndian
85
86 for name, test := range testEndians(&buf) {
87 var expectedReadWrite int64
88
89 for n, tests := range tests {
90 buf = buf[:0]
91
92 for i, d := range tests {
93 rw.write(test.StickyEndianWriter, d)
94
95 if len(buf) != numBytes {
96 t.Errorf("%s%s%d (%d.%d): expected to write %d byte, wrote %d", name, tname, 8*numBytes, n+1, i+1, numBytes, len(buf))
97 } else if got := rw.read(test.StickyEndianReader); got != d {
98 t.Errorf("%s%s%d (%d.%d): wanted %v, got %v", name, tname, 8*numBytes, n+1, i+1, d, got)
99 } else if len(buf) != 0 {
100 t.Errorf("%s%s%d (%d.%d): expected to have read all bytes, %d remain", name, tname, 8*numBytes, n+1, i+1, len(buf))
101 }
102 }
103
104 expectedReadWrite += int64(len(tests) * numBytes)
105
106 if written := test.StickyEndianWriter.GetCount(); written != expectedReadWrite && !isMem(test) {
107 t.Errorf("%s%s%d (%d.1): expected to write %d bytes, read %d", name, tname, 8*numBytes, n+1, expectedReadWrite, written)
108 } else if read := test.StickyEndianReader.GetCount(); read != expectedReadWrite && !isMem(test) {
109 t.Errorf("%s%s%d (%d.1): expected to read %d bytes, read %d", name, tname, 8*numBytes, n+1, expectedReadWrite, read)
110 }
111 }
112 }
113
114 buf.Write(testBytes[:numBytes])
115
116 if read := rw.read(&StickyLittleEndianReader{Reader: &buf}); read != expectedLittle {
117 t.Errorf("LittleEndian%s%d: expected to read value %v, got %v", tname, 8*numBytes, expectedLittle, read)
118 }
119
120 buf.Write(testBytes[:numBytes])
121
122 if read := rw.read(&StickyBigEndianReader{Reader: &buf}); read != expectedBig {
123 t.Errorf("BigEndian%s%d: expected to read value %v, got %v", tname, 8*numBytes, expectedBig, read)
124 }
125 }
126
127 func Test8(t *testing.T) {
128 testReadWrite(t, "Uint", 1, readWrite[uint64]{
129 read: func(s StickyEndianReader) uint64 {
130 return uint64(s.ReadUint8())
131 },
132 write: func(s StickyEndianWriter, n uint64) {
133 s.WriteUint8(uint8(n))
134 },
135 }, testUints[:1], 0x01, 0x01)
136
137 testReadWrite(t, "Int", 1, readWrite[int64]{
138 read: func(s StickyEndianReader) int64 {
139 return int64(s.ReadInt8())
140 },
141 write: func(s StickyEndianWriter, n int64) {
142 s.WriteInt8(int8(n))
143 },
144 }, testInts[:1], 0x01, 0x01)
145 }
146
147 func Test16(t *testing.T) {
148 testReadWrite(t, "Uint", 2, readWrite[uint64]{
149 read: func(s StickyEndianReader) uint64 {
150 return uint64(s.ReadUint16())
151 },
152 write: func(s StickyEndianWriter, n uint64) {
153 s.WriteUint16(uint16(n))
154 },
155 }, testUints[:2], 0x0201, 0x0102)
156 testReadWrite(t, "Int", 2, readWrite[int64]{
157 read: func(s StickyEndianReader) int64 {
158 return int64(s.ReadInt16())
159 },
160 write: func(s StickyEndianWriter, n int64) {
161 s.WriteInt16(int16(n))
162 },
163 }, testInts[:2], 0x0201, 0x0102)
164 }
165
166 func Test24(t *testing.T) {
167 testReadWrite(t, "Uint", 3, readWrite[uint64]{
168 read: func(s StickyEndianReader) uint64 {
169 return uint64(s.ReadUint24())
170 },
171 write: func(s StickyEndianWriter, n uint64) {
172 s.WriteUint24(uint32(n))
173 },
174 }, testUints[:3], 0x030201, 0x010203)
175 testReadWrite(t, "Ints", 3, readWrite[int64]{
176 read: func(s StickyEndianReader) int64 {
177 return int64(s.ReadInt24())
178 },
179 write: func(s StickyEndianWriter, n int64) {
180 s.WriteInt24(int32(n))
181 },
182 }, testInts[:3], 0x030201, 0x010203)
183 }
184
185 func Test32(t *testing.T) {
186 testReadWrite(t, "Uint", 4, readWrite[uint64]{
187 read: func(s StickyEndianReader) uint64 {
188 return uint64(s.ReadUint32())
189 },
190 write: func(s StickyEndianWriter, n uint64) {
191 s.WriteUint32(uint32(n))
192 },
193 }, testUints[:4], 0x04030201, 0x01020304)
194 testReadWrite(t, "Int", 4, readWrite[int64]{
195 read: func(s StickyEndianReader) int64 {
196 return int64(s.ReadInt32())
197 },
198 write: func(s StickyEndianWriter, n int64) {
199 s.WriteInt32(int32(n))
200 },
201 }, testInts[:4], 0x04030201, 0x01020304)
202 }
203
204 func Test40(t *testing.T) {
205 testReadWrite(t, "Uint", 5, readWrite[uint64]{
206 read: func(s StickyEndianReader) uint64 {
207 return s.ReadUint40()
208 },
209 write: func(s StickyEndianWriter, n uint64) {
210 s.WriteUint40(n)
211 },
212 }, testUints[:5], 0x0504030201, 0x0102030405)
213 testReadWrite(t, "Int", 5, readWrite[int64]{
214 read: func(s StickyEndianReader) int64 {
215 return s.ReadInt40()
216 },
217 write: func(s StickyEndianWriter, n int64) {
218 s.WriteInt40(n)
219 },
220 }, testInts[:5], 0x0504030201, 0x0102030405)
221 }
222
223 func Test48(t *testing.T) {
224 testReadWrite(t, "Uint", 6, readWrite[uint64]{
225 read: func(s StickyEndianReader) uint64 {
226 return s.ReadUint48()
227 },
228 write: func(s StickyEndianWriter, n uint64) {
229 s.WriteUint48(n)
230 },
231 }, testUints[:6], 0x060504030201, 0x010203040506)
232 testReadWrite(t, "Int", 6, readWrite[int64]{
233 read: func(s StickyEndianReader) int64 {
234 return s.ReadInt48()
235 },
236 write: func(s StickyEndianWriter, n int64) {
237 s.WriteInt48(n)
238 },
239 }, testInts[:6], 0x060504030201, 0x010203040506)
240 }
241
242 func Test56(t *testing.T) {
243 testReadWrite(t, "Uint", 7, readWrite[uint64]{
244 read: func(s StickyEndianReader) uint64 {
245 return s.ReadUint56()
246 },
247 write: func(s StickyEndianWriter, n uint64) {
248 s.WriteUint56(n)
249 },
250 }, testUints[:7], 0x07060504030201, 0x01020304050607)
251 testReadWrite(t, "Int", 7, readWrite[int64]{
252 read: func(s StickyEndianReader) int64 {
253 return s.ReadInt56()
254 },
255 write: func(s StickyEndianWriter, n int64) {
256 s.WriteInt56(n)
257 },
258 }, testInts[:7], 0x07060504030201, 0x01020304050607)
259 }
260
261 func Test64(t *testing.T) {
262 testReadWrite(t, "Uint", 8, readWrite[uint64]{
263 read: func(s StickyEndianReader) uint64 {
264 return s.ReadUint64()
265 },
266 write: func(s StickyEndianWriter, n uint64) {
267 s.WriteUint64(n)
268 },
269 }, testUints, 0x0807060504030201, 0x0102030405060708)
270 testReadWrite(t, "Int", 8, readWrite[int64]{
271 read: func(s StickyEndianReader) int64 {
272 return s.ReadInt64()
273 },
274 write: func(s StickyEndianWriter, n int64) {
275 s.WriteInt64(n)
276 },
277 }, testInts, 0x0807060504030201, 0x0102030405060708)
278 }
279
280 func TestFloat32(t *testing.T) {
281 testReadWrite(t, "Float", 4, readWrite[float64]{
282 read: func(s StickyEndianReader) float64 {
283 return float64(s.ReadFloat32())
284 },
285 write: func(s StickyEndianWriter, n float64) {
286 s.WriteFloat32(float32(n))
287 },
288 }, testFloats[:1], float64(math.Float32frombits(0x04030201)), float64(math.Float32frombits(0x01020304)))
289 }
290
291 func TestFloat64(t *testing.T) {
292 testReadWrite(t, "Float", 8, readWrite[float64]{
293 read: func(s StickyEndianReader) float64 {
294 return s.ReadFloat64()
295 },
296 write: func(s StickyEndianWriter, n float64) {
297 s.WriteFloat64(n)
298 },
299 }, testFloats, math.Float64frombits(0x0807060504030201), math.Float64frombits(0x0102030405060708))
300 }
301
302 func TestBool(t *testing.T) {
303 testReadWrite(t, "Bool", 1, readWrite[bool]{
304 read: func(s StickyEndianReader) bool {
305 return s.ReadBool()
306 },
307 write: func(s StickyEndianWriter, n bool) {
308 s.WriteBool(n)
309 },
310 }, [][]bool{{true, false}}, true, true)
311 }
312