1030 lines
21 KiB
Go
1030 lines
21 KiB
Go
package enc
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"math"
|
|
"slices"
|
|
"testing"
|
|
|
|
bin "gordenko.dev/dima/bin/little"
|
|
"gordenko.dev/dima/qb"
|
|
)
|
|
|
|
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
|
|
|
|
func TestValueDeltaCompressor(t *testing.T) {
|
|
var (
|
|
testCases = []struct {
|
|
Nums []float64
|
|
Name string
|
|
Offset int
|
|
ChangeSize int
|
|
Buf []byte
|
|
BaseValue float64
|
|
LastDelta uint64
|
|
}{
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
},
|
|
Name: "add 1st value",
|
|
Offset: 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",
|
|
Offset: 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",
|
|
Offset: 2,
|
|
ChangeSize: 3,
|
|
Buf: []byte{
|
|
0x8f, // base value
|
|
0x80, // delta 0
|
|
0x80, // literal (len = 1)
|
|
0x81, // delta 10
|
|
0x00, // run (len = 2)
|
|
0x00, 0x00, 0x00,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 1,
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
},
|
|
Name: "increment run",
|
|
Offset: 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",
|
|
Offset: 0,
|
|
ChangeSize: 2,
|
|
Buf: []byte{
|
|
0x8f, // base value
|
|
0x80, // delta 0
|
|
0x01, // run (len = 3)
|
|
0x81, // delta 10
|
|
0x80, // literal (len = 1)
|
|
0x00, 0x00, 0x00,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 1,
|
|
},
|
|
// {
|
|
// Nums: []float64{
|
|
// 1.5,
|
|
// },
|
|
// RepeatLastDeltaNTimes: 128,
|
|
// Code: incrementRun, // h byte full filled
|
|
// RequiredSpace: 2,
|
|
// Buf: []byte{
|
|
// 143, // base value
|
|
// 0, 0, 0, 0, 0, 0, 0,
|
|
// },
|
|
// BaseValue: 1.5,
|
|
// LastDelta: 0,
|
|
// H: 127, // run, length = 129
|
|
// },
|
|
// {
|
|
// Nums: []float64{
|
|
// 1.5,
|
|
// },
|
|
// RepeatLastDeltaNTimes: 129,
|
|
// Code: endSeries, // run, h byte overflowed
|
|
// RequiredSpace: 4, // run delta, h of run, 1st literal delta, h of literal
|
|
// Buf: []byte{
|
|
// 143, // base value
|
|
// 128, // run delta (0)
|
|
// 127, // h of run (length = 129)
|
|
// 0, 0, 0, 0, 0,
|
|
// },
|
|
// BaseValue: 1.5,
|
|
// LastDelta: 0,
|
|
// H: 128, // literal, length = 1
|
|
// },
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
1.7,
|
|
},
|
|
Name: "increment literal",
|
|
Offset: 1,
|
|
ChangeSize: 2,
|
|
Buf: []byte{
|
|
0x8f, // base value
|
|
0x80, // delta 0
|
|
0x81, // delta 10
|
|
0x82, // delta 20
|
|
0x82, // literal (len = 3)
|
|
0x00, 0x00, 0x00,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 2,
|
|
},
|
|
}
|
|
)
|
|
|
|
for _, testCase := range testCases {
|
|
var (
|
|
tmp = make([]byte, tmpValueSize)
|
|
fracDigits byte = 1
|
|
buf = make([]byte, 8)
|
|
payloadSize = 0
|
|
report qb.ValueEvaluationReport
|
|
)
|
|
c := NewValueDeltaCompressor(fracDigits, buf, payloadSize)
|
|
for _, num := range testCase.Nums {
|
|
report = c.Evaluate(tmp, num)
|
|
c.Append(report.Offset, tmp[:report.ChangeSize], num, report.Delta)
|
|
}
|
|
if report.Offset != testCase.Offset {
|
|
t.Fatalf("%s: got offset %d are not equal expected %d",
|
|
testCase.Name, report.Offset, testCase.Offset)
|
|
}
|
|
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 TestCumulativeDeltaDecompressorFromState(t *testing.T) {
|
|
var (
|
|
testCases = []struct {
|
|
Nums []float64
|
|
//RepeatLastDeltaNTimes int
|
|
}{
|
|
{
|
|
// addBaseValue
|
|
Nums: []float64{
|
|
1.5,
|
|
},
|
|
},
|
|
{
|
|
// startRun
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
},
|
|
},
|
|
{
|
|
// startRun
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
1.6,
|
|
},
|
|
},
|
|
{
|
|
// incrementRun
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
},
|
|
},
|
|
{
|
|
// endSeries run
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
1.6,
|
|
},
|
|
},
|
|
{
|
|
// incrementLiteral
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
},
|
|
},
|
|
{
|
|
// ...
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5, //
|
|
1.5, //
|
|
1.6, //
|
|
1.7, //
|
|
1.8, //
|
|
1.9, //
|
|
2.0, //
|
|
2.0, //
|
|
2.0, //
|
|
2.2, //
|
|
},
|
|
},
|
|
}
|
|
)
|
|
for caseIdx, testCase := range testCases {
|
|
var (
|
|
fracDigits byte = 1
|
|
buf = make([]byte, 16)
|
|
payloadSize = 0
|
|
decodedNums []float64
|
|
)
|
|
c := NewCumulativeDeltaCompressor(fracDigits, buf, payloadSize)
|
|
for _, num := range testCase.Nums {
|
|
compressionWay, _ := c.Evaluate(num)
|
|
c.Compress(compressionWay, num)
|
|
}
|
|
|
|
//
|
|
c.CaptureState()
|
|
|
|
fmt.Println("---------------")
|
|
|
|
d := c.CreateDecompressor()
|
|
|
|
//fmt.Println(buf)
|
|
|
|
for {
|
|
num, done := d.NextValue()
|
|
//fmt.Println(num, done)
|
|
if done {
|
|
break
|
|
}
|
|
decodedNums = append(decodedNums, num)
|
|
}
|
|
|
|
slices.Reverse(decodedNums)
|
|
|
|
fmt.Println(testCase.Nums)
|
|
fmt.Println(decodedNums)
|
|
fmt.Println()
|
|
|
|
if !equalFloatSlices(testCase.Nums, decodedNums, 0.0000001) {
|
|
t.Fatalf("%d: got nums %v not equal expected %v", caseIdx, decodedNums, testCase.Nums)
|
|
}
|
|
}
|
|
}
|
|
|
|
// INSTANT
|
|
|
|
func TestInstantDeltaCompressor(t *testing.T) {
|
|
var (
|
|
testCases = []struct {
|
|
Nums []float64
|
|
RepeatLastDeltaNTimes int
|
|
Code int
|
|
RequiredSpace int
|
|
Buf []byte
|
|
BaseValue float64
|
|
LastDelta int64
|
|
H byte
|
|
}{
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
},
|
|
Code: addBaseValue,
|
|
RequiredSpace: 3, // base value, delta, h
|
|
Buf: []byte{
|
|
158, 0, 0, 0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 0,
|
|
H: 128, // literal, length = 1
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
},
|
|
Code: startRun, // literal changed to run
|
|
RequiredSpace: 2, // delta, h
|
|
Buf: []byte{
|
|
158, 0, 0, 0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 0,
|
|
H: 0, // run, length = 2
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
1.6,
|
|
},
|
|
Code: startRun, // literal decreased by 1
|
|
RequiredSpace: 3, // end of literal, new delta, new h
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // literal 1st delta (0)
|
|
128, // h - end of literal, length = 1
|
|
0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 1,
|
|
H: 0, // run, length = 2
|
|
},
|
|
{
|
|
// same as prev, but negative delta
|
|
Nums: []float64{
|
|
1.5,
|
|
1.4,
|
|
1.4,
|
|
},
|
|
Code: startRun, // literal decreased by 1
|
|
RequiredSpace: 3, // end of literal, new delta, new h
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // literal 1st delta (0)
|
|
128, // h - end of literal, length = 1
|
|
0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: -1,
|
|
H: 0, // run, length = 2
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
},
|
|
Code: incrementRun,
|
|
RequiredSpace: 2,
|
|
Buf: []byte{
|
|
158, // base value
|
|
0, 0, 0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 0,
|
|
H: 1, // run, length = 3
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
1.6,
|
|
},
|
|
Code: endSeries, // end of run
|
|
RequiredSpace: 4,
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // run delta (0)
|
|
1, // h of run, length = 3
|
|
0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 1,
|
|
H: 128, // literal, length = 1
|
|
},
|
|
{
|
|
// same as prev, but negative delta
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
1.4,
|
|
},
|
|
Code: endSeries, // end of run
|
|
RequiredSpace: 4,
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // run delta (0)
|
|
1, // h of run, length = 3
|
|
0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: -1,
|
|
H: 128, // literal, length = 1
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
},
|
|
RepeatLastDeltaNTimes: 128,
|
|
Code: incrementRun, // h byte full filled
|
|
RequiredSpace: 2,
|
|
Buf: []byte{
|
|
158, // base value
|
|
0, 0, 0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 0,
|
|
H: 127, // run, length = 129
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
},
|
|
RepeatLastDeltaNTimes: 129,
|
|
Code: endSeries, // run, h byte overflowed
|
|
RequiredSpace: 4, // run delta, h of run, 1st literal delta, h of literal
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // run delta (0)
|
|
127, // h of run (length = 129)
|
|
0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 0,
|
|
H: 128, // literal, length = 1
|
|
},
|
|
{
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
},
|
|
Code: incrementLiteral,
|
|
RequiredSpace: 3, // previous delta, new delta, h
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // literal 1st delta (0)
|
|
0, 0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: 1,
|
|
H: 129, // literal, length = 2
|
|
},
|
|
{
|
|
// same as prev, but negative delta
|
|
Nums: []float64{
|
|
1.5,
|
|
1.4,
|
|
},
|
|
Code: incrementLiteral,
|
|
RequiredSpace: 3, // previous delta, new delta, h
|
|
Buf: []byte{
|
|
158, // base value
|
|
128, // literal 1st delta (0)
|
|
0, 0, 0, 0, 0, 0,
|
|
},
|
|
BaseValue: 1.5,
|
|
LastDelta: -1,
|
|
H: 129, // literal, length = 2
|
|
},
|
|
}
|
|
)
|
|
|
|
for caseIdx, testCase := range testCases {
|
|
var (
|
|
fracDigits byte = 1
|
|
buf = make([]byte, 8)
|
|
payloadSize = 0
|
|
compressionWay int
|
|
requiredSpace int
|
|
)
|
|
c := NewInstantDeltaCompressor(fracDigits, buf, payloadSize)
|
|
for _, num := range testCase.Nums {
|
|
compressionWay, requiredSpace = c.Evaluate(num)
|
|
c.Compress(compressionWay, num)
|
|
}
|
|
if testCase.RepeatLastDeltaNTimes > 0 {
|
|
num := testCase.Nums[len(testCase.Nums)-1]
|
|
for range testCase.RepeatLastDeltaNTimes {
|
|
compressionWay, requiredSpace = c.Evaluate(num)
|
|
c.Compress(compressionWay, num)
|
|
}
|
|
}
|
|
if compressionWay != testCase.Code {
|
|
t.Fatalf("%d: got code %d are not equal expected %d",
|
|
caseIdx, compressionWay, testCase.Code)
|
|
}
|
|
if requiredSpace != testCase.RequiredSpace {
|
|
t.Fatalf("%d: got requiredSpace %d are not equal expected %d",
|
|
caseIdx, requiredSpace, testCase.RequiredSpace)
|
|
}
|
|
if !bytes.Equal(buf, testCase.Buf) {
|
|
t.Fatalf("%d: got buf %v are not equal expected %v",
|
|
caseIdx, buf, testCase.Buf)
|
|
}
|
|
if c.baseValue != testCase.BaseValue {
|
|
t.Fatalf("%d: got lastUnixtime %v are not equal expected %v",
|
|
caseIdx, c.baseValue, testCase.BaseValue)
|
|
}
|
|
if c.lastDelta != testCase.LastDelta {
|
|
t.Fatalf("%d: got lastDelta %d are not equal expected %d",
|
|
caseIdx, c.lastDelta, testCase.LastDelta)
|
|
}
|
|
if c.h != testCase.H {
|
|
t.Fatalf("%d: got h %d are not equal expected %d",
|
|
caseIdx, c.h, testCase.H)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInstantDeltaDecompressorFromState(t *testing.T) {
|
|
var (
|
|
testCases = []struct {
|
|
Nums []float64
|
|
//RepeatLastDeltaNTimes int
|
|
}{
|
|
{
|
|
// addBaseValue
|
|
Nums: []float64{
|
|
1.5,
|
|
},
|
|
},
|
|
{
|
|
// startRun
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
},
|
|
},
|
|
{
|
|
// startRun
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
1.6,
|
|
},
|
|
},
|
|
{
|
|
// incrementRun
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
},
|
|
},
|
|
{
|
|
// endSeries run
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5,
|
|
1.6,
|
|
},
|
|
},
|
|
{
|
|
// incrementLiteral
|
|
Nums: []float64{
|
|
1.5,
|
|
1.6,
|
|
},
|
|
},
|
|
{
|
|
// ...
|
|
Nums: []float64{
|
|
1.5,
|
|
1.5,
|
|
1.5, //
|
|
1.5, //
|
|
1.6, //
|
|
1.7, //
|
|
1.8, //
|
|
1.9, //
|
|
2.0, //
|
|
2.0, //
|
|
2.0, //
|
|
2.2, //
|
|
},
|
|
},
|
|
}
|
|
)
|
|
for caseIdx, testCase := range testCases {
|
|
var (
|
|
fracDigits byte = 1
|
|
buf = make([]byte, 16)
|
|
payloadSize = 0
|
|
decodedNums []float64
|
|
)
|
|
c := NewInstantDeltaCompressor(fracDigits, buf, payloadSize)
|
|
for _, num := range testCase.Nums {
|
|
compressionWay, _ := c.Evaluate(num)
|
|
c.Compress(compressionWay, num)
|
|
}
|
|
|
|
//
|
|
c.CaptureState()
|
|
|
|
fmt.Println("---------------")
|
|
|
|
d := c.CreateDecompressor()
|
|
|
|
//fmt.Println(buf)
|
|
|
|
for {
|
|
num, done := d.NextValue()
|
|
//fmt.Println(num, done)
|
|
if done {
|
|
break
|
|
}
|
|
decodedNums = append(decodedNums, num)
|
|
}
|
|
|
|
slices.Reverse(decodedNums)
|
|
|
|
fmt.Println(testCase.Nums)
|
|
fmt.Println(decodedNums)
|
|
fmt.Println()
|
|
|
|
if !equalFloatSlices(testCase.Nums, decodedNums, 0.0000001) {
|
|
t.Fatalf("%d: got nums %v not equal expected %v", caseIdx, decodedNums, testCase.Nums)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TIME DELTA
|
|
|
|
func TestTimeDeltaCompressor(t *testing.T) {
|
|
var (
|
|
testCases = []struct {
|
|
Name string
|
|
Nums []uint32
|
|
Buf []byte
|
|
LastUnixtime uint32
|
|
LastDelta uint32
|
|
Offset int
|
|
ChangeSize int
|
|
}{
|
|
{
|
|
Nums: []uint32{
|
|
1780777000,
|
|
},
|
|
Name: "add 1st value",
|
|
Offset: 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",
|
|
Offset: 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",
|
|
Offset: 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",
|
|
Offset: 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",
|
|
Offset: 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",
|
|
Offset: 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: []uint32{
|
|
// 1780777000,
|
|
// 1780777060, // +60
|
|
// },
|
|
// RepeatLastDeltaNTimes: 128,
|
|
// CompressionWay: incrementRun, // h byte full filled
|
|
// RequiredSpace: 6,
|
|
// 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: 1780777060 + 128*60,
|
|
// LastDelta: 60,
|
|
// H: 127, // run, length = 129
|
|
// },
|
|
// {
|
|
// Nums: []uint32{
|
|
// 1780777000,
|
|
// 1780777060, // +60
|
|
// },
|
|
// RepeatLastDeltaNTimes: 129,
|
|
// CompressionWay: endSeries, // run, h byte overflowed
|
|
// RequiredSpace: 8,
|
|
// Buf: []byte{
|
|
// 0, 0, 0, 0, 0, 0,
|
|
// 127, // h - end of run (length = 129)
|
|
// 188, // varUint64(60)
|
|
// },
|
|
// LastUnixtime: 1780777060 + 129*60,
|
|
// LastDelta: 60,
|
|
// H: 128, // literal, length = 1
|
|
// },
|
|
{
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777060, // +60
|
|
1780777130, // +70
|
|
},
|
|
Name: "increment literal",
|
|
Offset: 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,
|
|
},
|
|
}
|
|
)
|
|
|
|
for _, testCase := range testCases {
|
|
//fmt.Println("----------")
|
|
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)
|
|
|
|
// fmt.Println("----------\npos", c.pos)
|
|
// fmt.Printf("buf: % x\n", c.buf[c.pos:])
|
|
// pretty.Println(report)
|
|
// fmt.Printf("change: % x\n", tmp[:report.ChangeSize])
|
|
c.Append(report.Offset, tmp[:report.ChangeSize], num)
|
|
}
|
|
if report.Offset != testCase.Offset {
|
|
t.Fatalf("%s: got offset %d are not equal expected %d",
|
|
testCase.Name, report.Offset, testCase.Offset)
|
|
}
|
|
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 TestTimeDeltaDecompressorFromState(t *testing.T) {
|
|
var (
|
|
testCases = []struct {
|
|
Nums []uint32
|
|
//RepeatLastDeltaNTimes int
|
|
}{
|
|
{
|
|
Nums: []uint32{
|
|
1780777000,
|
|
},
|
|
},
|
|
{
|
|
// add1stDelta
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777060, // +60
|
|
},
|
|
},
|
|
{
|
|
// startRun
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777060, // +60
|
|
1780777120, // +60
|
|
},
|
|
},
|
|
{
|
|
// incrementRun
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777060, // +60
|
|
1780777120, // +60
|
|
1780777180, // +60
|
|
},
|
|
},
|
|
{
|
|
// endRun
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777060, // +60
|
|
1780777120, // +60
|
|
1780777180, // +60
|
|
1780777200, // +20
|
|
},
|
|
},
|
|
{
|
|
// incrementLiteral
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777060, // +60
|
|
1780777122, // +62
|
|
},
|
|
},
|
|
{
|
|
// ...
|
|
Nums: []uint32{
|
|
1780777000,
|
|
1780777010, // +10
|
|
1780777120, // +10
|
|
1780777130, // +10
|
|
1780777135, // +5
|
|
1780777141, // +6
|
|
1780777148, // +7
|
|
1780777156, // +8
|
|
1780777165, // +9
|
|
1780777174, // +9
|
|
1780777183, // +9
|
|
1780777190, // +7
|
|
},
|
|
},
|
|
}
|
|
)
|
|
for caseIdx, testCase := range testCases {
|
|
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.Offset, tmp[:report.ChangeSize], num)
|
|
}
|
|
|
|
//
|
|
c.CaptureState()
|
|
|
|
d := c.CreateDecompressor()
|
|
|
|
//fmt.Println(testCase.Nums)
|
|
// fmt.Println("---------------")
|
|
// fmt.Println(buf)
|
|
|
|
for {
|
|
num, done := d.NextValue()
|
|
//fmt.Println(num, done)
|
|
if done {
|
|
break
|
|
}
|
|
decodedNums = append(decodedNums, num)
|
|
}
|
|
|
|
slices.Reverse(decodedNums)
|
|
|
|
if !slices.Equal(testCase.Nums, decodedNums) {
|
|
t.Fatalf("%d: got nums %v not equal expected %v", caseIdx, decodedNums, testCase.Nums)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVarUint64(t *testing.T) {
|
|
arr := make([]byte, 9)
|
|
n, err := bin.PutVarInt64(arr, 15)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fmt.Println(arr[:n])
|
|
}
|