aboutsummaryrefslogtreecommitdiff
path: root/bitreader_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'bitreader_test.go')
-rw-r--r--bitreader_test.go164
1 files changed, 143 insertions, 21 deletions
diff --git a/bitreader_test.go b/bitreader_test.go
index 5d344d2..ef13dfe 100644
--- a/bitreader_test.go
+++ b/bitreader_test.go
@@ -1,17 +1,102 @@
1package bitreader 1package main
2 2
3import ( 3import (
4 "bytes"
4 "testing" 5 "testing"
5) 6)
6 7
7// 01110001, 00001101, 00000000, 00000000, 10100010, 00011011, 00000000, 00000000, 11001100 8// 01110001, 00001101, 00000000, 00000000, 10100010, 00011011, 00000000, 00000000, 11001100
8var TestArray = [...]byte{113, 13, 0, 0, 162, 27, 0, 0, 204} 9var TestArray = [...]byte{113, 13, 0, 0, 162, 27, 0, 0, 204}
9 10
11func TestTryReadFloat32(t *testing.T) {
12 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
13 expected := []float32{6.98198182157e+29, -2.10064170919e-18}
14 for i := range expected {
15 value, err := bitreader.TryReadFloat32()
16 if err != nil {
17 t.Fatal(err)
18 }
19 if value != expected[i] {
20 t.Fatalf("TryReadFloat32 FAIL for index %d: Expected %f, Got %f", i, expected[i], value)
21 }
22 }
23}
24
25func TestTryReadFloat64(t *testing.T) {
26 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
27 expected := []float64{3.68828741038253948851462939603e+236}
28 for i := range expected {
29 value, err := bitreader.TryReadFloat64()
30 if err != nil {
31 t.Fatal(err)
32 }
33 if value != expected[i] {
34 t.Fatalf("TryReadFloat64 FAIL for index %d: Expected %f, Got %f", i, expected[i], value)
35 }
36 }
37}
38
39func TestTryReadInt8(t *testing.T) {
40 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
41 expected := []int{113, 13, 0}
42 for i := range expected {
43 value, err := bitreader.TryReadInt8()
44 if err != nil {
45 t.Fatal(err)
46 }
47 if int(value) != expected[i] {
48 t.Fatalf("TryReadInt8 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
49 }
50 }
51}
52
53func TestTryReadInt16(t *testing.T) {
54 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
55 expected := []int{28941, 0, 41499, 0}
56 for i := range expected {
57 value, err := bitreader.TryReadInt16()
58 if err != nil {
59 t.Fatal(err)
60 }
61 if int(value) != expected[i] {
62 t.Fatalf("TryReadInt16 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
63 }
64 }
65}
66
67func TestTryReadInt32(t *testing.T) {
68 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
69 expected := []int{1896677376, 2719678464}
70 for i := range expected {
71 value, err := bitreader.TryReadInt32()
72 if err != nil {
73 t.Fatal(err)
74 }
75 if int(value) != expected[i] {
76 t.Fatalf("TryReadInt32 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
77 }
78 }
79}
80
81func TestTryReadInt64(t *testing.T) {
82 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
83 expected := []int{8146167303702773760}
84 for i := range expected {
85 value, err := bitreader.TryReadInt64()
86 if err != nil {
87 t.Fatal(err)
88 }
89 if int(value) != expected[i] {
90 t.Fatalf("TryReadInt64 FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
91 }
92 }
93}
94
10func TestReadBit(t *testing.T) { 95func TestReadBit(t *testing.T) {
11 bitreader := Reader(TestArray[:], false) 96 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
12 expected := []bool{false, true, true, true} 97 expected := []bool{false, true, true, true}
13 for i := range expected { 98 for i := range expected {
14 value, err := bitreader.ReadBit() 99 value, err := bitreader.ReadBool()
15 if err != nil { 100 if err != nil {
16 t.Fatal(err) 101 t.Fatal(err)
17 } 102 }
@@ -22,27 +107,27 @@ func TestReadBit(t *testing.T) {
22} 107}
23 108
24func TestReadBitLE(t *testing.T) { 109func TestReadBitLE(t *testing.T) {
25 bitreader := Reader(TestArray[:], true) 110 bitreader := Reader(bytes.NewBuffer(TestArray[:]), true)
26 expected := []bool{true, false, false, false} 111 expected := []bool{true, false, false, false}
27 for i := range expected { 112 for i := range expected {
28 value, err := bitreader.ReadBit() 113 value, err := bitreader.ReadBool()
29 if err != nil { 114 if err != nil {
30 t.Fatal(err) 115 t.Fatal(err)
31 } 116 }
32 if value != expected[i] { 117 if value != expected[i] {
33 t.Fatalf("ReadBitLSB FAIL for index %d: Expected %t, Got %t", i, expected[i], value) 118 t.Fatalf("ReadBitLE FAIL for index %d: Expected %t, Got %t", i, expected[i], value)
34 } 119 }
35 } 120 }
36} 121}
37 122
38func TestReadBits32(t *testing.T) { 123func TestReadBits(t *testing.T) {
39 bitreader := Reader(TestArray[:], false) 124 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
40 expected := []int{3793354753, 2288779267} // 11100010000110100000000000000001, 10001000011011000000000000000011 125 expected := []int{3793354753, 2288779267} // 11100010000110100000000000000001, 10001000011011000000000000000011
41 expectedBool := []bool{false, false} 126 expectedBool := []bool{false, false}
42 for i := range expected { 127 for i := range expected {
43 bool, err := bitreader.ReadBit() 128 bool, err := bitreader.ReadBool()
44 if bool != expectedBool[i] { 129 if bool != expectedBool[i] {
45 t.Fatalf("ReadBits32 ReadBit FAIL for index %d: Expected %t, Got %t", i, expectedBool[i], bool) 130 t.Fatalf("ReadBits ReadBit FAIL for index %d: Expected %t, Got %t", i, expectedBool[i], bool)
46 } 131 }
47 if err != nil { 132 if err != nil {
48 t.Fatal(err) 133 t.Fatal(err)
@@ -51,36 +136,73 @@ func TestReadBits32(t *testing.T) {
51 if err != nil { 136 if err != nil {
52 t.Fatal(err) 137 t.Fatal(err)
53 } 138 }
54 if value != expected[i] { 139 if int(value) != expected[i] {
55 t.Fatalf("ReadBits32 FAIL for index %d: Expected %d, Got %d", i, expected[i], value) 140 t.Fatalf("ReadBits FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
56 } 141 }
57 } 142 }
58} 143}
59 144
60func TestReadBitsLE(t *testing.T) { 145func TestReadBitsLE(t *testing.T) {
61 bitreader := Reader(TestArray[:], true) 146 bitreader := Reader(bytes.NewBuffer(TestArray[:]), true)
62 expected := []int{1720, 1768} // 11010111000, 11011101000 147 expected := []int{1720, 1768} // 11010111000, 11011101000
63 for i := range expected { 148 for i := range expected {
64 bitreader.ReadBit() 149 bitreader.ReadBool()
65 value, err := bitreader.ReadBits(32) 150 value, err := bitreader.ReadBits(32)
66 if err != nil { 151 if err != nil {
67 t.Fatal(err) 152 t.Fatal(err)
68 } 153 }
69 if value != expected[i] { 154 if int(value) != expected[i] {
70 t.Fatalf("ReadBits32LSB FAIL for index %d: Expected %d, Got %d", i, expected[i], value) 155 t.Fatalf("ReadBitsLE FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
156 }
157 }
158}
159
160func TestReadBytes(t *testing.T) {
161 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
162 expected := []int{3793354753, 2288779267} // 11100010000110100000000000000001, 10001000011011000000000000000011
163 expectedBool := []bool{false, false}
164 for i := range expected {
165 bool, err := bitreader.ReadBool()
166 if bool != expectedBool[i] {
167 t.Fatalf("ReadBytes ReadBit FAIL for index %d: Expected %t, Got %t", i, expectedBool[i], bool)
168 }
169 if err != nil {
170 t.Fatal(err)
171 }
172 value, err := bitreader.ReadBytes(4)
173 if err != nil {
174 t.Fatal(err)
175 }
176 if int(value) != expected[i] {
177 t.Fatalf("ReadBytes FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
178 }
179 }
180}
181
182func TestReadBytesLE(t *testing.T) {
183 bitreader := Reader(bytes.NewBuffer(TestArray[:]), true)
184 expected := []int{1720, 1768} // 11010111000, 11011101000
185 for i := range expected {
186 bitreader.ReadBool()
187 value, err := bitreader.ReadBytes(4)
188 if err != nil {
189 t.Fatal(err)
190 }
191 if int(value) != expected[i] {
192 t.Fatalf("ReadBytesLE FAIL for index %d: Expected %d, Got %d", i, expected[i], value)
71 } 193 }
72 } 194 }
73} 195}
74 196
75func TestSkipBits(t *testing.T) { 197func TestSkipBits(t *testing.T) {
76 bitreader := Reader(TestArray[:], false) 198 bitreader := Reader(bytes.NewBuffer(TestArray[:]), false)
77 expected := []bool{true, true, false, true} //00001101 199 expected := []bool{true, true, false, true} //00001101
78 err := bitreader.SkipBits(12) 200 err := bitreader.SkipBits(12)
79 if err != nil { 201 if err != nil {
80 t.Fatal(err) 202 t.Fatal(err)
81 } 203 }
82 for i := range expected { 204 for i := range expected {
83 value, err := bitreader.ReadBit() 205 value, err := bitreader.ReadBool()
84 if err != nil { 206 if err != nil {
85 t.Fatal(err) 207 t.Fatal(err)
86 } 208 }
@@ -91,16 +213,16 @@ func TestSkipBits(t *testing.T) {
91} 213}
92 214
93func TestSkipBitsLE(t *testing.T) { 215func TestSkipBitsLE(t *testing.T) {
94 bitreader := Reader(TestArray[:], true) 216 bitreader := Reader(bytes.NewBuffer(TestArray[:]), true)
95 expected := []bool{false, false, false, false} //10110000 217 expected := []bool{false, false, false, false} //10110000
96 bitreader.SkipBits(12) 218 bitreader.SkipBits(12)
97 for i := range expected { 219 for i := range expected {
98 value, err := bitreader.ReadBit() 220 value, err := bitreader.ReadBool()
99 if err != nil { 221 if err != nil {
100 t.Fatal(err) 222 t.Fatal(err)
101 } 223 }
102 if value != expected[i] { 224 if value != expected[i] {
103 t.Fatalf("SkipBits ReadBit FAIL for index %d: Expected %t, Got %t", i, expected[i], value) 225 t.Fatalf("SkipBitsLE ReadBit FAIL for index %d: Expected %t, Got %t", i, expected[i], value)
104 } 226 }
105 } 227 }
106} 228}
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-08 21:40:17 +0000