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 BenchmarkEncoder(b *testing.B) {
x := make([]uint64, 1024)
for i := 0; i < len(x); i++ {
x[i] = uint64(15)
}
enc := simple8b.NewEncoder()
b.ResetTimer()
for i := 0; i < b.N; i++ {
enc.(valueSetter).SetValues(x)
enc.Bytes()
b.SetBytes(int64(len(x)) * 8)
}
}
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 Test_Encode_ValueTooLarge(t *testing.T) {
enc := simple8b.NewEncoder()
values := []uint64{
1442369134000000000, 0,
}
for _, v := range values {
enc.Write(v)
}
_, err := enc.Bytes()
if err == nil {
t.Fatalf("Expected error, got nil")
}
}
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 (e *encoder) encodePacked(div uint64, dts []uint64) ([]byte, error) {
enc := simple8b.NewEncoder()
for _, v := range dts[1:] {
enc.Write(uint64(v) / div)
}
b := make([]byte, 8+1)
// 4 high bits used for the encoding type
b[0] = byte(timeCompressedPackedSimple) << 4
// 4 low bits are the log10 divisor
b[0] |= byte(math.Log10(float64(div)))
// The first delta value
binary.BigEndian.PutUint64(b[1:9], uint64(dts[0]))
// The compressed deltas
deltas, err := enc.Bytes()
if err != nil {
return nil, err
}
return append(b, deltas...), nil
}
// NewTimeEncoder returns a TimeEncoder
func NewTimeEncoder(sz int) TimeEncoder {
return &encoder{
ts: make([]uint64, 0, sz),
enc: simple8b.NewEncoder(),
}
}