func testEncode(t *testing.T, n int, val uint64) {
enc := simple8b.NewEncoder()
in := make([]uint64, n)
for i := 0; i < n; i++ {
in[i] = val
enc.Write(in[i])
}
encoded, err := enc.Bytes()
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
dec := simple8b.NewDecoder(encoded)
i := 0
for dec.Next() {
if i >= len(in) {
t.Fatalf("Decoded too many values: got %v, exp %v", i, len(in))
}
if dec.Read() != in[i] {
t.Fatalf("Decoded[%d] != %v, got %v", i, in[i], dec.Read())
}
i += 1
}
if exp, got := n, i; got != exp {
t.Fatalf("Decode len mismatch: exp %v, got %v", exp, got)
}
}
func CountTimestamps(b []byte) int {
if len(b) == 0 {
return 0
}
// Encoding type is stored in the 4 high bits of the first byte
encoding := b[0] >> 4
switch encoding {
case timeUncompressed:
// Uncompressed timestamps are just 8 bytes each
return len(b[1:]) / 8
case timeCompressedRLE:
// First 9 bytes are the starting timestamp and scaling factor, skip over them
i := 9
// Next 1-10 bytes is our (scaled down by factor of 10) run length values
_, n := binary.Uvarint(b[9:])
i += n
// Last 1-10 bytes is how many times the value repeats
count, _ := binary.Uvarint(b[i:])
return int(count)
case timeCompressedPackedSimple:
// First 9 bytes are the starting timestamp and scaling factor, skip over them
dec := simple8b.NewDecoder(b[9:])
count := 1
// Count the deltas
for dec.Next() {
count++
}
return count
default:
return 0
}
}
func Test_Bytes(t *testing.T) {
enc := simple8b.NewEncoder()
for i := 0; i < 30; i++ {
enc.Write(uint64(i))
}
b, _ := enc.Bytes()
dec := simple8b.NewDecoder(b)
x := uint64(0)
for dec.Next() {
if x != dec.Read() {
t.Fatalf("mismatch: got %v, exp %v", dec.Read(), x)
}
x += 1
}
}
func (d *decoder) decodePacked(b []byte) {
div := uint64(math.Pow10(int(b[0] & 0xF)))
first := uint64(binary.BigEndian.Uint64(b[1:9]))
enc := simple8b.NewDecoder(b[9:])
deltas := []uint64{first}
for enc.Next() {
deltas = append(deltas, enc.Read())
}
// Compute the prefix sum and scale the deltas back up
for i := 1; i < len(deltas); i++ {
dgap := deltas[i] * div
deltas[i] = deltas[i-1] + dgap
}
d.ts = deltas
}
func BenchmarkDecoder(b *testing.B) {
enc := simple8b.NewEncoder()
x := make([]uint64, 1024)
for i := 0; i < len(x); i++ {
x[i] = uint64(10)
enc.Write(x[i])
}
y, _ := enc.Bytes()
b.ResetTimer()
dec := simple8b.NewDecoder(y)
for i := 0; i < b.N; i++ {
dec.(byteSetter).SetBytes(y)
j := 0
for dec.Next() {
j += 1
}
b.SetBytes(int64(j * 8))
}
}
func NewTimeDecoder() TimeDecoder {
return &decoder{
dec: simple8b.NewDecoder(nil),
}
}
func Test_Decode_NotEnoughBytes(t *testing.T) {
dec := simple8b.NewDecoder([]byte{0})
if dec.Next() {
t.Fatalf("Expected Next to return false but it returned true")
}
}