11673223716

Committed 04 Nov 2024 09:45PM UTC coverage: 75.259% (+8.4%) from 66.885%

Build # 11673223716

Build Type

Pull #380

github

Committed by

tobbee

Commit Message

test: more unit tests

Pull Request Pull Request #380: Refactor and much better test coverage

Run Details

498 of 616 new or added lines in 17 files covered. (80.84%)

326 existing lines in 27 files now uncovered.

14698 of 19530 relevant lines covered (75.26%)

0.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.86

/bits/fixedslicereader.go

package bits

import (
        "encoding/binary"
        "errors"
        "fmt"
)

// FixedSliceReader - read integers and other data from a fixed slice.
// Accumulates error, and the first error can be retrieved.
// If err != nil, 0 or empty string is returned
type FixedSliceReader struct {
        err   error
        slice []byte
        pos   int
        len   int
}

// bits.NewFixedSliceReader creates a new slice reader reading from data
func NewFixedSliceReader(data []byte) *FixedSliceReader {
        return &FixedSliceReader{
                slice: data,
                pos:   0,
                len:   len(data),
                err:   nil,
        }
}

// AccError - get accumulated error after read operations
func (s *FixedSliceReader) AccError() error {
        return s.err
}

// ReadUint8 - read uint8 from slice
func (s *FixedSliceReader) ReadUint8() byte {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-1 {
                s.err = ErrSliceRead
                return 0
        }
        res := s.slice[s.pos]
        s.pos++
        return res
}

// ReadUint16 - read uint16 from slice
func (s *FixedSliceReader) ReadUint16() uint16 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-2 {
                s.err = ErrSliceRead
                return 0
        }
        res := binary.BigEndian.Uint16(s.slice[s.pos : s.pos+2])
        s.pos += 2
        return res
}

// ReadInt16 - read int16 from slice
func (s *FixedSliceReader) ReadInt16() int16 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-2 {
                s.err = ErrSliceRead
                return 0
        }
        res := binary.BigEndian.Uint16(s.slice[s.pos : s.pos+2])
        s.pos += 2
        return int16(res)
}

// ReadUint24 - read uint24 from slice
func (s *FixedSliceReader) ReadUint24() uint32 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-3 {
                s.err = ErrSliceRead
                return 0
        }
        res := uint32(binary.BigEndian.Uint16(s.slice[s.pos : s.pos+2]))
        res = res<<8 | uint32(s.slice[s.pos+2])
        s.pos += 3
        return res
}

// ReadUint32 - read uint32 from slice
func (s *FixedSliceReader) ReadUint32() uint32 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-4 {
                s.err = ErrSliceRead
                return 0
        }
        res := binary.BigEndian.Uint32(s.slice[s.pos : s.pos+4])
        s.pos += 4
        return res
}

// ReadInt32 - read int32 from slice
func (s *FixedSliceReader) ReadInt32() int32 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-4 {
                s.err = ErrSliceRead
                return 0
        }
        res := binary.BigEndian.Uint32(s.slice[s.pos : s.pos+4])
        s.pos += 4
        return int32(res)
}

// ReadUint64 - read uint64 from slice
func (s *FixedSliceReader) ReadUint64() uint64 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-8 {
                s.err = ErrSliceRead
                return 0
        }
        res := binary.BigEndian.Uint64(s.slice[s.pos : s.pos+8])
        s.pos += 8
        return res
}

// ReadInt64 - read int64 from slice
func (s *FixedSliceReader) ReadInt64() int64 {
        if s.err != nil {
                return 0
        }
        if s.pos > s.len-8 {
                s.err = ErrSliceRead
                return 0
        }
        res := binary.BigEndian.Uint64(s.slice[s.pos : s.pos+8])
        s.pos += 8
        return int64(res)
}

// ReadFixedLengthString - read string of specified length n.
// Sets err and returns empty string if full length not available
func (s *FixedSliceReader) ReadFixedLengthString(n int) string {
        if s.err != nil {
                return ""
        }
        if s.pos > s.len-n {
                s.err = ErrSliceRead
                return ""
        }
        res := string(s.slice[s.pos : s.pos+n])
        s.pos += n
        return res
}

// ReadZeroTerminatedString - read string until zero byte but at most maxLen
// Set err and return empty string if no zero byte found.
func (s *FixedSliceReader) ReadZeroTerminatedString(maxLen int) string {
        if s.err != nil {
                return ""
        }
        startPos := s.pos
        maxPos := startPos + maxLen
        for {
                if s.pos >= maxPos {
                        s.err = errors.New("did not find terminating zero")
                        return ""
                }
                c := s.slice[s.pos]
                if c == 0 {
                        str := string(s.slice[startPos:s.pos])
                        s.pos++ // Next position to read
                        return str
                }
                s.pos++
        }
}

// ReadPossiblyZeroTerminatedString - read string until zero byte but at most maxLen.
// If maxLen is reached and no zero-byte, return string and ok = false
func (s *FixedSliceReader) ReadPossiblyZeroTerminatedString(maxLen int) (str string, ok bool) {
        startPos := s.pos
        maxPos := startPos + maxLen
        for {
                if s.pos == maxPos {
                        return string(s.slice[startPos:s.pos]), true
                }
                if s.pos > maxPos {
                        s.err = errors.New("did not find terminating zero")
                        return "", false
                }
                c := s.slice[s.pos]
                if c == 0 {
                        str = string(s.slice[startPos:s.pos])
                        s.pos++ // Next position to read
                        return str, true
                }
                s.pos++
        }
}

// ReadBytes - read a slice of n bytes
// Return empty slice if n bytes not available
func (s *FixedSliceReader) ReadBytes(n int) []byte {
        if s.err != nil {
                return []byte{}
        }
        if s.pos > s.len-n {
                s.err = ErrSliceRead
                return []byte{}
        }
        res := s.slice[s.pos : s.pos+n]
        s.pos += n
        return res
}

// RemainingBytes - return remaining bytes of this slice
func (s *FixedSliceReader) RemainingBytes() []byte {
        if s.err != nil {
                return []byte{}
        }
        res := s.slice[s.pos:]
        s.pos = s.Length()
        return res
}

// NrRemainingBytes - return number of bytes remaining
func (s *FixedSliceReader) NrRemainingBytes() int {
        if s.err != nil {
                return 0
        }
        return s.Length() - s.GetPos()
}

// SkipBytes - skip passed n bytes
func (s *FixedSliceReader) SkipBytes(n int) {
        if s.err != nil {
                return
        }
        if s.pos+n > s.Length() {
                s.err = fmt.Errorf("attempt to skip bytes to pos %d beyond slice len %d", s.pos+n, s.len)
                return
        }
        s.pos += n
}

// SetPos - set read position is slice
func (s *FixedSliceReader) SetPos(pos int) {
        if pos > s.len {
                s.err = fmt.Errorf("attempt to set pos %d beyond slice len %d", pos, s.len)
                return
        }
        s.pos = pos
}

// GetPos - get read position is slice
func (s *FixedSliceReader) GetPos() int {
        return s.pos
}

// Length - get length of slice
func (s *FixedSliceReader) Length() int {
        return s.len
}

// LookAhead returns data ahead of current pos if within bounds.
func (s *FixedSliceReader) LookAhead(offset int, data []byte) error {
        if s.pos+offset+len(data) > s.len {
                return fmt.Errorf("out of bounds")
        }
        copy(data, s.slice[s.pos+offset:])
        return nil
}

1	package bits
2
3	import (
4	"encoding/binary"
5	"errors"
6	"fmt"
7	)
8
9	// FixedSliceReader - read integers and other data from a fixed slice.
10	// Accumulates error, and the first error can be retrieved.
11	// If err != nil, 0 or empty string is returned
12	type FixedSliceReader struct {
13	err error
14	slice []byte
15	pos int
16	len int
17	}
18
19	// bits.NewFixedSliceReader creates a new slice reader reading from data
20	func NewFixedSliceReader(data []byte) *FixedSliceReader {	1✔
21	return &FixedSliceReader{	1✔
22	slice: data,	1✔
23	pos: 0,	1✔
24	len: len(data),	1✔
25	err: nil,	1✔
26	}	1✔
27	}	1✔
28
29	// AccError - get accumulated error after read operations
30	func (s *FixedSliceReader) AccError() error {	1✔
31	return s.err	1✔
32	}	1✔
33
34	// ReadUint8 - read uint8 from slice
35	func (s *FixedSliceReader) ReadUint8() byte {	1✔
36	if s.err != nil {	2✔
37	return 0	1✔
38	}	1✔
39	if s.pos > s.len-1 {	2✔
40	s.err = ErrSliceRead	1✔
41	return 0	1✔
42	}	1✔
43	res := s.slice[s.pos]	1✔
44	s.pos++	1✔
45	return res	1✔
46	}
47
48	// ReadUint16 - read uint16 from slice
49	func (s *FixedSliceReader) ReadUint16() uint16 {	1✔
50	if s.err != nil {	2✔
51	return 0	1✔
52	}	1✔
53	if s.pos > s.len-2 {	2✔
54	s.err = ErrSliceRead	1✔
55	return 0	1✔
56	}	1✔
57	res := binary.BigEndian.Uint16(s.slice[s.pos : s.pos+2])	1✔
58	s.pos += 2	1✔
59	return res	1✔
60	}
61
62	// ReadInt16 - read int16 from slice
63	func (s *FixedSliceReader) ReadInt16() int16 {	1✔
64	if s.err != nil {	2✔
65	return 0	1✔
66	}	1✔
67	if s.pos > s.len-2 {	2✔
68	s.err = ErrSliceRead	1✔
69	return 0	1✔
70	}	1✔
71	res := binary.BigEndian.Uint16(s.slice[s.pos : s.pos+2])	1✔
72	s.pos += 2	1✔
73	return int16(res)	1✔
74	}
75
76	// ReadUint24 - read uint24 from slice
77	func (s *FixedSliceReader) ReadUint24() uint32 {	1✔
78	if s.err != nil {	2✔
79	return 0	1✔
80	}	1✔
81	if s.pos > s.len-3 {	2✔
82	s.err = ErrSliceRead	1✔
83	return 0	1✔
84	}	1✔
85	res := uint32(binary.BigEndian.Uint16(s.slice[s.pos : s.pos+2]))	1✔
86	res = res<<8 \| uint32(s.slice[s.pos+2])	1✔
87	s.pos += 3	1✔
88	return res	1✔
89	}
90
91	// ReadUint32 - read uint32 from slice
92	func (s *FixedSliceReader) ReadUint32() uint32 {	1✔
93	if s.err != nil {	2✔
94	return 0	1✔
95	}	1✔
96	if s.pos > s.len-4 {	2✔
97	s.err = ErrSliceRead	1✔
98	return 0	1✔
99	}	1✔
100	res := binary.BigEndian.Uint32(s.slice[s.pos : s.pos+4])	1✔
101	s.pos += 4	1✔
102	return res	1✔
103	}
104
105	// ReadInt32 - read int32 from slice
106	func (s *FixedSliceReader) ReadInt32() int32 {	1✔
107	if s.err != nil {	2✔
108	return 0	1✔
109	}	1✔
110	if s.pos > s.len-4 {	2✔
111	s.err = ErrSliceRead	1✔
112	return 0	1✔
113	}	1✔
114	res := binary.BigEndian.Uint32(s.slice[s.pos : s.pos+4])	1✔
115	s.pos += 4	1✔
116	return int32(res)	1✔
117	}
118
119	// ReadUint64 - read uint64 from slice
120	func (s *FixedSliceReader) ReadUint64() uint64 {	1✔
121	if s.err != nil {	2✔
122	return 0	1✔
123	}	1✔
124	if s.pos > s.len-8 {	2✔
125	s.err = ErrSliceRead	1✔
126	return 0	1✔
127	}	1✔
128	res := binary.BigEndian.Uint64(s.slice[s.pos : s.pos+8])	1✔
129	s.pos += 8	1✔
130	return res	1✔
131	}
132
133	// ReadInt64 - read int64 from slice
134	func (s *FixedSliceReader) ReadInt64() int64 {	1✔
135	if s.err != nil {	2✔
136	return 0	1✔
137	}	1✔
138	if s.pos > s.len-8 {	2✔
139	s.err = ErrSliceRead	1✔
140	return 0	1✔
141	}	1✔
142	res := binary.BigEndian.Uint64(s.slice[s.pos : s.pos+8])	1✔
143	s.pos += 8	1✔
144	return int64(res)	1✔
145	}
146
147	// ReadFixedLengthString - read string of specified length n.
148	// Sets err and returns empty string if full length not available
149	func (s *FixedSliceReader) ReadFixedLengthString(n int) string {	1✔
150	if s.err != nil {	2✔
151	return ""	1✔
152	}	1✔
153	if s.pos > s.len-n {	2✔
154	s.err = ErrSliceRead	1✔
155	return ""	1✔
156	}	1✔
157	res := string(s.slice[s.pos : s.pos+n])	1✔
158	s.pos += n	1✔
159	return res	1✔
160	}
161
162	// ReadZeroTerminatedString - read string until zero byte but at most maxLen
163	// Set err and return empty string if no zero byte found.
164	func (s *FixedSliceReader) ReadZeroTerminatedString(maxLen int) string {	1✔
165	if s.err != nil {	2✔
166	return ""	1✔
167	}	1✔
168	startPos := s.pos	1✔
169	maxPos := startPos + maxLen	1✔
170	for {	2✔
171	if s.pos >= maxPos {	2✔
172	s.err = errors.New("did not find terminating zero")	1✔
173	return ""	1✔
174	}	1✔
175	c := s.slice[s.pos]	1✔
176	if c == 0 {	2✔
177	str := string(s.slice[startPos:s.pos])	1✔
178	s.pos++ // Next position to read	1✔
179	return str	1✔
180	}	1✔
181	s.pos++	1✔
182	}
183	}
184
185	// ReadPossiblyZeroTerminatedString - read string until zero byte but at most maxLen.
186	// If maxLen is reached and no zero-byte, return string and ok = false
UNCOV 187	func (s *FixedSliceReader) ReadPossiblyZeroTerminatedString(maxLen int) (str string, ok bool) {	×
UNCOV 188	startPos := s.pos	×
UNCOV 189	maxPos := startPos + maxLen	×
UNCOV 190	for {	×
UNCOV 191	if s.pos == maxPos {	×
UNCOV 192	return string(s.slice[startPos:s.pos]), true	×
UNCOV 193	}	×
UNCOV 194	if s.pos > maxPos {	×
195	s.err = errors.New("did not find terminating zero")	×
196	return "", false	×
197	}	×
UNCOV 198	c := s.slice[s.pos]	×
UNCOV 199	if c == 0 {	×
UNCOV 200	str = string(s.slice[startPos:s.pos])	×
UNCOV 201	s.pos++ // Next position to read	×
UNCOV 202	return str, true	×
UNCOV 203	}	×
UNCOV 204	s.pos++	×
205	}
206	}
207
208	// ReadBytes - read a slice of n bytes
209	// Return empty slice if n bytes not available
210	func (s *FixedSliceReader) ReadBytes(n int) []byte {	1✔
211	if s.err != nil {	2✔
212	return []byte{}	1✔
213	}	1✔
214	if s.pos > s.len-n {	2✔
215	s.err = ErrSliceRead	1✔
216	return []byte{}	1✔
217	}	1✔
218	res := s.slice[s.pos : s.pos+n]	1✔
219	s.pos += n	1✔
220	return res	1✔
221	}
222
223	// RemainingBytes - return remaining bytes of this slice
224	func (s *FixedSliceReader) RemainingBytes() []byte {	1✔
225	if s.err != nil {	2✔
226	return []byte{}	1✔
227	}	1✔
228	res := s.slice[s.pos:]	1✔
229	s.pos = s.Length()	1✔
230	return res	1✔
231	}
232
233	// NrRemainingBytes - return number of bytes remaining
234	func (s *FixedSliceReader) NrRemainingBytes() int {	1✔
235	if s.err != nil {	2✔
236	return 0	1✔
237	}	1✔
238	return s.Length() - s.GetPos()	1✔
239	}
240
241	// SkipBytes - skip passed n bytes
242	func (s *FixedSliceReader) SkipBytes(n int) {	1✔
243	if s.err != nil {	2✔
244	return	1✔
245	}	1✔
246	if s.pos+n > s.Length() {	2✔
247	s.err = fmt.Errorf("attempt to skip bytes to pos %d beyond slice len %d", s.pos+n, s.len)	1✔
248	return	1✔
249	}	1✔
250	s.pos += n	1✔
251	}
252
253	// SetPos - set read position is slice
254	func (s *FixedSliceReader) SetPos(pos int) {	1✔
255	if pos > s.len {	2✔
256	s.err = fmt.Errorf("attempt to set pos %d beyond slice len %d", pos, s.len)	1✔
257	return	1✔
258	}	1✔
259	s.pos = pos	1✔
260	}
261
262	// GetPos - get read position is slice
263	func (s *FixedSliceReader) GetPos() int {	1✔
264	return s.pos	1✔
265	}	1✔
266
267	// Length - get length of slice
268	func (s *FixedSliceReader) Length() int {	1✔
269	return s.len	1✔
270	}	1✔
271
272	// LookAhead returns data ahead of current pos if within bounds.
273	func (s *FixedSliceReader) LookAhead(offset int, data []byte) error {	1✔
274	if s.pos+offset+len(data) > s.len {	2✔
275	return fmt.Errorf("out of bounds")	1✔
276	}	1✔
277	copy(data, s.slice[s.pos+offset:])	1✔
278	return nil	1✔
279	}

Eyevinn / mp4ff / 11673223716

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous