dima/qb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
qb/enc/enc_test.go
Dima Gordenko 2d73ce1727 wp
2026-06-19 07:25:46 +03:00

1300 lines
29 KiB
Go
Raw Permalink Blame History

package enc
import (
"bytes"
"fmt"
"math"
"slices"
"testing"
"time"
bin "gordenko.dev/dima/bin/little"
"gordenko.dev/dima/qb"
"gordenko.dev/dima/textutil"
)
func equalFloatSlices(a, b []float64, epsilon float64) bool {
return slices.EqualFunc(a, b, func(x, y float64) bool {
return math.Abs(x-y) <= epsilon
})
}
// CUMULATIVE
var (
cumulativeTestCases = []struct {
Nums []float64
Name string
RewindOffset int
ChangeSize int
Buf []byte
BaseValue float64
LastDelta uint64
}{
{
Nums: []float64{
0,
},
Name: "add 1st value zero",
RewindOffset: 0,
ChangeSize: 3,
Buf: []byte{
0x80, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 0,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
},
Name: "add 1st value non zero",
RewindOffset: 0,
ChangeSize: 3,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.5,
},
Name: "literal switch to run",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x00, // run (len = 2)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.6,
1.6,
},
Name: "literal decrease by 1 and switch to run",
RewindOffset: 2,
ChangeSize: 3,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x81, // delta 1
0x00, // run (len = 2)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 1,
},
{
Nums: []float64{
1.5,
1.5,
1.5,
},
Name: "increment run",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.5,
1.5,
1.6,
},
Name: "run switch to literal",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x81, // delta 1
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 1,
},
{
Nums: repeatFloat64(1.5, 129),
Name: "increment run to full fill h-byte",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x7f, // run (len = 129)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: repeatFloat64(1.5, 130),
Name: "run switch to literal after h-byte overflow",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x7f, // run (len = 129)
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.6,
1.7,
},
Name: "increment literal",
RewindOffset: 1,
ChangeSize: 2,
Buf: []byte{
0x8f, // base value
0x80, // delta 0
0x81, // delta 1
0x82, // delta 2
0x82, // literal (len = 3)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 2,
},
}
)
func TestCumulativeDeltaCompressor(t *testing.T) {
for _, testCase := range cumulativeTestCases {
var (
tmp = make([]byte, tmpValueSize)
metricType = qb.Cumulative
fracDigits byte = 1
buf = make([]byte, 8)
payloadSize = 0
report qb.ValueEvaluationReport
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report = c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
if report.RewindOffset != testCase.RewindOffset {
t.Fatalf("%s: got offset %d are not equal expected %d",
testCase.Name, report.RewindOffset, testCase.RewindOffset)
}
if report.ChangeSize != testCase.ChangeSize {
t.Fatalf("%s: got changeSize %d are not equal expected %d",
testCase.Name, report.ChangeSize, testCase.ChangeSize)
}
if !bytes.Equal(buf, testCase.Buf) {
t.Fatalf("%s: got buf % x are not equal expected % x",
testCase.Name, buf, testCase.Buf)
}
if c.baseValue != testCase.BaseValue {
t.Fatalf("%s: got baseValue %v are not equal expected %v",
testCase.Name, c.baseValue, testCase.BaseValue)
}
if c.lastDelta != testCase.LastDelta {
t.Fatalf("%s: got lastDelta %d are not equal expected %d",
testCase.Name, c.lastDelta, testCase.LastDelta)
}
}
}
func TestRestoreCumulativeDeltaCompressor(t *testing.T) {
for _, testCase := range cumulativeTestCases {
var (
tmp = make([]byte, tmpValueSize)
metricType = qb.Cumulative
fracDigits byte = 1
buf = make([]byte, 8)
payloadSize = 0
report qb.ValueEvaluationReport
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report = c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
restored := NewValueDeltaCompressor(metricType, fracDigits, buf, c.Size())
if restored.baseValue != testCase.BaseValue {
t.Fatalf("%s: got baseValue %v are not equal expected %v",
testCase.Name, restored.baseValue, testCase.BaseValue)
}
if restored.lastDelta != testCase.LastDelta {
t.Fatalf("%s: got lastDelta %d are not equal expected %d",
testCase.Name, restored.lastDelta, testCase.LastDelta)
}
}
}
func TestCumulativeDeltaDecompressorFromState(t *testing.T) {
for _, testCase := range cumulativeTestCases {
var (
metricType = qb.Cumulative
fracDigits byte = 1
tmp = make([]byte, tmpValueSize)
buf = make([]byte, 16)
payloadSize = 0
decodedNums []float64
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
d := c.CreateDecompressor(metricType, fracDigits)
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !equalFloatSlices(testCase.Nums, decodedNums, 0.0000001) {
t.Fatalf("%s: got nums %v not equal expected %v",
testCase.Name, decodedNums, testCase.Nums)
}
}
}
func TestCumulativeDeltaDecompressorFromEnd(t *testing.T) {
for _, testCase := range cumulativeTestCases {
var (
metricType = qb.Cumulative
fracDigits byte = 1
tmp = make([]byte, tmpValueSize)
buf = make([]byte, 16)
payloadSize = 0
decodedNums []float64
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
d := NewValueDeltaDecompressor(metricType, fracDigits)
d.RestoreFromEnd(buf[:c.Size()])
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !equalFloatSlices(testCase.Nums, decodedNums, 0.0000001) {
t.Fatalf("%s: got nums %v not equal expected %v",
testCase.Name, decodedNums, testCase.Nums)
}
}
}
// INSTANT
var (
instantTestCases = []struct {
Nums []float64
Name string
RewindOffset int
ChangeSize int
Buf []byte
BaseValue float64
LastDelta uint64
}{
{
Nums: []float64{
1.5,
},
Name: "add 1st value",
RewindOffset: 0,
ChangeSize: 3,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
-1.5,
},
Name: "add 1st value (negative)",
RewindOffset: 0,
ChangeSize: 3,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.5,
},
Name: "literal switch to run",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x00, // run (len = 2)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
-1.5,
-1.5,
},
Name: "literal switch to run (negative)",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x00, // run (len = 2)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.6,
1.6,
},
Name: "literal decrease by 1 and switch to run",
RewindOffset: 2,
ChangeSize: 3,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x82, // delta 1
0x00, // run (len = 2)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: bin.EncodeZigZag(1),
},
{
Nums: []float64{
-1.5,
-1.6,
-1.6,
},
Name: "literal decrease by 1 and switch to run (negative)",
RewindOffset: 2,
ChangeSize: 3,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x81, // delta -1
0x00, // run (len = 2)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: bin.EncodeZigZag(-1),
},
{
Nums: []float64{
1.5,
1.4,
1.4,
},
Name: "literal decrease by 1 and switch to run (negative delta)",
RewindOffset: 2,
ChangeSize: 3,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x81, // delta -1
0x00, // run (len = 2)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: bin.EncodeZigZag(-1),
},
{
Nums: []float64{
-1.5,
-1.4,
-1.4,
},
Name: "literal decrease by 1 and switch to run (positive delta, negative)",
RewindOffset: 2,
ChangeSize: 3,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x80, // literal (len = 1)
0x82, // delta 1
0x00, // run (len = 2)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: bin.EncodeZigZag(1),
},
{
Nums: []float64{
1.5,
1.5,
1.5,
},
Name: "increment run",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: []float64{
-1.5,
-1.5,
-1.5,
},
Name: "increment run (negative)",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.5,
1.5,
1.6,
},
Name: "run switch to literal",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x82, // delta 1
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: bin.EncodeZigZag(1),
},
{
Nums: []float64{
-1.5,
-1.5,
-1.5,
-1.6,
},
Name: "run switch to literal (negative)",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x81, // delta -1
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: bin.EncodeZigZag(-1),
},
{
Nums: []float64{
1.5,
1.5,
1.5,
1.4,
},
Name: "run switch to literal (negative delta)",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x81, // delta -1
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: bin.EncodeZigZag(-1),
},
{
Nums: []float64{
-1.5,
-1.5,
-1.5,
-1.4,
},
Name: "run switch to literal (positive delta, negative version)",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x01, // run (len = 3)
0x82, // delta 1
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: bin.EncodeZigZag(1),
},
{
Nums: repeatFloat64(1.5, 129),
Name: "increment run to full fill h-byte",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x7f, // run (len = 129)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: repeatFloat64(-1.5, 129),
Name: "increment run to full fill h-byte (negative version)",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x7f, // run (len = 129)
0x00, 0x00, 0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: 0,
},
{
Nums: repeatFloat64(1.5, 130),
Name: "run switch to literal after h-byte overflow",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x7f, // run (len = 129)
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: 0,
},
{
Nums: repeatFloat64(-1.5, 130),
Name: "run switch to literal after h-byte overflow (negative version)",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x7f, // run (len = 129)
0x80, // delta 0
0x80, // literal (len = 1)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: 0,
},
{
Nums: []float64{
1.5,
1.6,
1.7,
},
Name: "increment literal",
RewindOffset: 1,
ChangeSize: 2,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x82, // delta 1
0x84, // delta 2
0x82, // literal (len = 3)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: bin.EncodeZigZag(2),
},
{
Nums: []float64{
-1.5,
-1.6,
-1.7,
},
Name: "increment literal (negative version)",
RewindOffset: 1,
ChangeSize: 2,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x81, // delta -1
0x83, // delta -2
0x82, // literal (len = 3)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: bin.EncodeZigZag(-2),
},
{
Nums: []float64{
1.5,
1.4,
1.3,
},
Name: "increment literal (negative delta)",
RewindOffset: 1,
ChangeSize: 2,
Buf: []byte{
0x9e, // base value
0x80, // delta 0
0x81, // delta -1
0x83, // delta -2
0x82, // literal (len = 3)
0x00, 0x00, 0x00,
},
BaseValue: 1.5,
LastDelta: bin.EncodeZigZag(-2),
},
{
Nums: []float64{
-1.5,
-1.4,
-1.3,
},
Name: "increment literal (positive delta, negative version)",
RewindOffset: 1,
ChangeSize: 2,
Buf: []byte{
0x9d, // base value
0x80, // delta 0
0x82, // delta 1
0x84, // delta 2
0x82, // literal (len = 3)
0x00, 0x00, 0x00,
},
BaseValue: -1.5,
LastDelta: bin.EncodeZigZag(2),
},
}
)
func TestInstantDeltaCompressor(t *testing.T) {
for _, testCase := range instantTestCases {
var (
tmp = make([]byte, tmpValueSize)
metricType = qb.Instant
fracDigits byte = 1
buf = make([]byte, 8)
payloadSize = 0
report qb.ValueEvaluationReport
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report = c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
if report.RewindOffset != testCase.RewindOffset {
t.Fatalf("%s: got rewindOffset %d are not equal expected %d",
testCase.Name, report.RewindOffset, testCase.RewindOffset)
}
if report.ChangeSize != testCase.ChangeSize {
t.Fatalf("%s: got changeSize %d are not equal expected %d",
testCase.Name, report.ChangeSize, testCase.ChangeSize)
}
if !bytes.Equal(buf, testCase.Buf) {
t.Fatalf("%s: got buf % x are not equal expected % x",
testCase.Name, buf, testCase.Buf)
}
if c.baseValue != testCase.BaseValue {
t.Fatalf("%s: got baseValue %v are not equal expected %v",
testCase.Name, c.baseValue, testCase.BaseValue)
}
if c.lastDelta != testCase.LastDelta {
t.Fatalf("%s: got lastDelta %d are not equal expected %d",
testCase.Name, c.lastDelta, testCase.LastDelta)
}
}
}
func TestRestoreInstantDeltaCompressor(t *testing.T) {
for _, testCase := range instantTestCases {
var (
tmp = make([]byte, tmpValueSize)
metricType = qb.Instant
fracDigits byte = 1
buf = make([]byte, 8)
payloadSize = 0
report qb.ValueEvaluationReport
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report = c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
restored := NewValueDeltaCompressor(metricType, fracDigits, buf, c.Size())
if restored.baseValue != testCase.BaseValue {
t.Fatalf("%s: got baseValue %v are not equal expected %v",
testCase.Name, restored.baseValue, testCase.BaseValue)
}
if restored.lastDelta != testCase.LastDelta {
t.Fatalf("%s: got lastDelta %d are not equal expected %d",
testCase.Name, restored.lastDelta, testCase.LastDelta)
}
}
}
func TestInstantDeltaDecompressorFromState(t *testing.T) {
for _, testCase := range instantTestCases {
var (
metricType = qb.Instant
fracDigits byte = 1
tmp = make([]byte, tmpValueSize)
buf = make([]byte, 16)
payloadSize = 0
decodedNums []float64
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
d := c.CreateDecompressor(metricType, fracDigits)
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !equalFloatSlices(testCase.Nums, decodedNums, 0.0000001) {
t.Fatalf("%s: got nums %v not equal expected %v",
testCase.Name, decodedNums, testCase.Nums)
}
}
}
func TestInstantDeltaDecompressorFromEnd(t *testing.T) {
for _, testCase := range instantTestCases {
var (
metricType = qb.Instant
fracDigits byte = 1
tmp = make([]byte, tmpValueSize)
buf = make([]byte, 8)
payloadSize = 0
decodedNums []float64
)
c := NewValueDeltaCompressor(metricType, fracDigits, buf, payloadSize)
for _, num := range testCase.Nums {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num, report.Delta)
}
d := NewValueDeltaDecompressor(metricType, fracDigits)
d.RestoreFromEnd(buf[:c.Size()])
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !equalFloatSlices(testCase.Nums, decodedNums, 0.0000001) {
t.Fatalf("%s: got nums %v not equal expected %v",
testCase.Name, decodedNums, testCase.Nums)
}
}
}
// TIME DELTA
var (
timeTestCases = []struct {
Name string
Nums []uint32
Buf []byte
LastUnixtime uint32
LastDelta uint32
RewindOffset int
ChangeSize int
}{
{
Nums: []uint32{
1780777000,
},
Name: "add 1st value",
RewindOffset: 0,
ChangeSize: 4,
Buf: []byte{
0x00, 0x00, 0x00, 0x00,
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777000,
LastDelta: 0,
},
{
Nums: []uint32{
1780777000,
1780777060, // +60
},
Name: "add 1st delta",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x00, 0x00,
0x80, // h-byte (literal, len=1)
0xbc, // delta (60)
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777060,
LastDelta: 60,
},
{
Nums: []uint32{
1780777000,
1780777060, // +60
1780777120, // +60
},
Name: "literal changed to run",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x00, 0x00,
0x00, // h-byte (run, len=2)
0xbc, // delta
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777120,
LastDelta: 60,
},
{
Nums: []uint32{
1780777000,
1780777060, // +60
1780777130, // +70
1780777200, // +70
},
Name: "literal decrease by 1 and switch to run",
RewindOffset: 2,
ChangeSize: 3,
Buf: []byte{
0x00, // h-byte (run, len=2)
0xc6, // delta 70
0x80, // h-byte (literal, len=1)
0xbc, // delta 60
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777200,
LastDelta: 70,
},
{
Nums: []uint32{
1780777000,
1780777060, // +60
1780777120, // +60
1780777180, // +60
},
Name: "increment run",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x00, 0x00,
0x01, // h-byte (run, len=2)
0xbc, // delta 60
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777180,
LastDelta: 60,
},
{
Nums: []uint32{
1780777000,
1780777060, // +60
1780777120, // +60
1780777180, // +60
1780777200, // +20
},
Name: "switch run to literal",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x80, // h-byte (literal, len=1)
0x94, // delta 20
0x01, // h-byte (run, len=3)
0xbc, // delta 60
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777200,
LastDelta: 20,
},
{
Nums: generateProgression(1780777000, 60, 130),
Name: "increment run up to full filled h-byte",
RewindOffset: 1,
ChangeSize: 1,
Buf: []byte{
0x00, 0x00,
0x7f, // h-byte (run, len=129)
0xbc, // delta 60
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777000 + 129*60,
LastDelta: 60,
},
{
Nums: generateProgression(1780777000, 60, 131),
Name: "run switch to literal after h-byte overflow",
RewindOffset: 0,
ChangeSize: 2,
Buf: []byte{
0x80, // h-byte (literal, len=1)
0xbc, // delta 60
0x7f, // h-byte (run, len=129)
0xbc, // delta 60
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777000 + 130*60,
LastDelta: 60,
},
{
Nums: []uint32{
1780777000,
1780777060, // +60
1780777130, // +70
},
Name: "increment literal",
RewindOffset: 1,
ChangeSize: 2,
Buf: []byte{
0x00,
0x81, // h-byte (literal, len=2)
0xc6, // delta 70
0xbc, // delta 60
0x28, 0x80, 0x24, 0x6a, // since
},
LastUnixtime: 1780777130,
LastDelta: 70,
},
}
)
func TestTimeDeltaCompressor(t *testing.T) {
for _, testCase := range timeTestCases {
var (
tmp = make([]byte, tmpTimeSize)
buf = make([]byte, 8)
payloadSize = 0
report qb.TimeEvaluationReport
)
c := NewTimeDeltaCompressor(buf, payloadSize)
for _, num := range testCase.Nums {
report = c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num)
}
if report.RewindOffset != testCase.RewindOffset {
t.Fatalf("%s: got rewindOffset %d are not equal expected %d",
testCase.Name, report.RewindOffset, testCase.RewindOffset)
}
if report.ChangeSize != testCase.ChangeSize {
t.Fatalf("%s: got changeSize %d are not equal expected %d",
testCase.Name, report.ChangeSize, testCase.ChangeSize)
}
if !bytes.Equal(buf, testCase.Buf) {
t.Fatalf("%s: got buf % x are not equal expected % x",
testCase.Name, buf, testCase.Buf)
}
if c.lastUnixtime != testCase.LastUnixtime {
t.Fatalf("%s: got lastUnixtime %d are not equal expected %d",
testCase.Name, c.lastUnixtime, testCase.LastUnixtime)
}
if c.lastDelta != testCase.LastDelta {
t.Fatalf("%s: got lastDelta %d are not equal expected %d",
testCase.Name, c.lastDelta, testCase.LastDelta)
}
}
}
func TestRestoreTimeDeltaCompressor(t *testing.T) {
for _, testCase := range timeTestCases {
var (
tmp = make([]byte, tmpTimeSize)
buf = make([]byte, 8)
payloadSize = 0
report qb.TimeEvaluationReport
)
c := NewTimeDeltaCompressor(buf, payloadSize)
for _, num := range testCase.Nums {
report = c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num)
}
restored := NewTimeDeltaCompressor(buf, c.Size())
if restored.lastUnixtime != testCase.LastUnixtime {
t.Fatalf("%s: got lastUnixtime %d are not equal expected %d",
testCase.Name, restored.lastUnixtime, testCase.LastUnixtime)
}
if restored.lastDelta != testCase.LastDelta {
t.Fatalf("%s: got lastDelta %d are not equal expected %d",
testCase.Name, restored.lastDelta, testCase.LastDelta)
}
}
}
func TestTimeDeltaDecompressorFromState(t *testing.T) {
for _, testCase := range timeTestCases {
var (
tmp = make([]byte, tmpTimeSize)
buf = make([]byte, 16)
payloadSize = 0
decodedNums []uint32
)
c := NewTimeDeltaCompressor(buf, payloadSize)
for _, num := range testCase.Nums {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num)
}
fmt.Println("-----")
d := c.CreateDecompressor()
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !slices.Equal(testCase.Nums, decodedNums) {
t.Fatalf("%s: got nums %v not equal expected %v",
testCase.Name, decodedNums, testCase.Nums)
}
}
}
func TestTimeDeltaDecompressorFromEnd(t *testing.T) {
for _, testCase := range timeTestCases {
var (
tmp = make([]byte, tmpTimeSize)
buf = make([]byte, 8)
payloadSize = 0
decodedNums []uint32
)
c := NewTimeDeltaCompressor(buf, payloadSize)
for _, num := range testCase.Nums {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num)
}
c.ReplaceSinceWithUntil()
d := NewTimeDeltaDecompressor()
d.RestoreFromEnd(buf[len(buf)-c.Size():])
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !slices.Equal(testCase.Nums, decodedNums) {
t.Fatalf("%s: got nums %v not equal expected %v",
testCase.Name, decodedNums, testCase.Nums)
}
}
}
func TestVarInt64(t *testing.T) {
arr := make([]byte, 9)
n, err := bin.PutVarInt64(arr, -15)
if err != nil {
t.Fatal(err)
}
fmt.Println(arr[:n])
}
func repeatFloat64(num float64, n int) []float64 {
nums := make([]float64, n)
for i := range nums {
nums[i] = num
}
return nums
}
func generateProgression(start uint32, delta uint32, n int) []uint32 {
nums := make([]uint32, n)
nums[0] = start
for i := 1; i < n; i++ {
nums[i] = nums[i-1] + delta
}
return nums
}
func generateTimestamps(days int) (timestamps []uint32) {
var (
minutes = []int{14, 29, 44, 59}
hoursPerDay = 24
totalHours = days * hoursPerDay
since = time.Now().AddDate(0, 0, -days)
)
for i := range totalHours {
hourTime := since.Add(time.Duration(i) * time.Hour)
for _, m := range minutes {
measureTime := time.Date(
hourTime.Year(),
hourTime.Month(),
hourTime.Day(),
hourTime.Hour(),
m, // minutes
0, // seconds
0, // nanoseconds
time.Local,
)
timestamps = append(timestamps, uint32(measureTime.Unix()))
}
}
return
}
func TestXXX(t *testing.T) {
var (
timestamps = generateTimestamps(20)[:1231]
tmp = make([]byte, tmpTimeSize)
buf = make([]byte, 64)
payloadSize = 0
decodedNums []uint32
)
c := NewTimeDeltaCompressor(buf, payloadSize)
for _, num := range timestamps {
report := c.Evaluate(tmp, num)
c.Append(report.RewindOffset, tmp[:report.ChangeSize], num)
}
d := c.CreateDecompressor()
for {
num, done := d.NextValue()
if done {
break
}
decodedNums = append(decodedNums, num)
}
slices.Reverse(decodedNums)
if !slices.Equal(timestamps, decodedNums) {
t.Fatalf("got nums %v not equal expected %v",
decodedNums, timestamps)
}
}
func TestYYY(t *testing.T) {
buf, err := textutil.ParseHex("50 04 87 ac 6b 05 6a")
if err != nil {
t.Fatal(err)
}
//var decodedNums []uint32
var prev uint32
d := NewTimeDeltaDecompressor()
d.RestoreFromEnd(buf)
for {
num, done := d.NextValue()
if done {
break
}
fmt.Println(num, prev-num)
prev = num
//decodedNums = append(decodedNums, num)
}
// //slices.Reverse(decodedNums)
// for _, num := range decodedNums {
// }
}
Reference in New Issue View Git Blame Copy Permalink