567 lines
15 KiB
Go
567 lines
15 KiB
Go
package prefixes_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"encoding/csv"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"math/big"
|
|
"os"
|
|
"sort"
|
|
"testing"
|
|
|
|
dbpkg "github.com/lbryio/herald.go/db"
|
|
prefixes "github.com/lbryio/herald.go/db/prefixes"
|
|
"github.com/linxGnu/grocksdb"
|
|
)
|
|
|
|
func TestPrefixRegistry(t *testing.T) {
|
|
for _, prefix := range prefixes.GetPrefixes() {
|
|
if prefixes.GetSerializationAPI(prefix) == nil {
|
|
t.Errorf("prefix %c not registered", prefix)
|
|
}
|
|
}
|
|
}
|
|
|
|
func testInit(filePath string) (*grocksdb.DB, [][]string, func(), *grocksdb.ColumnFamilyHandle) {
|
|
log.Println(filePath)
|
|
file, err := os.Open(filePath)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
reader := csv.NewReader(file)
|
|
records, err := reader.ReadAll()
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
columnFamily := records[0][0]
|
|
records = records[1:]
|
|
|
|
cleanupFiles := func() {
|
|
err = os.RemoveAll("./tmp")
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
}
|
|
|
|
// wOpts := grocksdb.NewDefaultWriteOptions()
|
|
opts := grocksdb.NewDefaultOptions()
|
|
opts.SetCreateIfMissing(true)
|
|
db, err := grocksdb.OpenDb(opts, "tmp")
|
|
if err != nil {
|
|
log.Println(err)
|
|
// Garbage might have been left behind by a prior crash.
|
|
cleanupFiles()
|
|
db, err = grocksdb.OpenDb(opts, "tmp")
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
}
|
|
handle, err := db.CreateColumnFamily(opts, columnFamily)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
toDefer := func() {
|
|
db.Close()
|
|
cleanupFiles()
|
|
}
|
|
|
|
return db, records, toDefer, handle
|
|
}
|
|
|
|
func testGeneric(filePath string, prefix byte, numPartials int) func(*testing.T) {
|
|
return func(t *testing.T) {
|
|
APIs := []*prefixes.SerializationAPI{
|
|
prefixes.GetSerializationAPI([]byte{prefix}),
|
|
// Verify combinations of production vs. "restruct" implementations of
|
|
// serialization API (e.g production Pack() with "restruct" Unpack()).
|
|
prefixes.RegressionAPI_1,
|
|
prefixes.RegressionAPI_2,
|
|
prefixes.RegressionAPI_3,
|
|
}
|
|
for _, api := range APIs {
|
|
opts := dbpkg.NewIterateOptions().WithPrefix([]byte{prefix}).WithSerializer(api).WithIncludeValue(true)
|
|
testGenericOptions(opts, filePath, prefix, numPartials)(t)
|
|
}
|
|
}
|
|
}
|
|
|
|
func testGenericOptions(options *dbpkg.IterOptions, filePath string, prefix byte, numPartials int) func(*testing.T) {
|
|
return func(t *testing.T) {
|
|
|
|
wOpts := grocksdb.NewDefaultWriteOptions()
|
|
db, records, toDefer, handle := testInit(filePath)
|
|
defer toDefer()
|
|
for _, record := range records {
|
|
key, err := hex.DecodeString(record[0])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
val, err := hex.DecodeString(record[1])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
// db.Put(wOpts, key, val)
|
|
db.PutCF(wOpts, handle, key, val)
|
|
}
|
|
// test prefix
|
|
options = options.WithCfHandle(handle)
|
|
ch := dbpkg.IterCF(db, options)
|
|
var i = 0
|
|
for kv := range ch {
|
|
// log.Println(kv.Key)
|
|
gotKey, err := options.Serializer.PackKey(kv.Key)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
|
|
if numPartials != kv.Key.NumFields() {
|
|
t.Errorf("key reports %v fields but %v expected", kv.Key.NumFields(), numPartials)
|
|
}
|
|
for j := 1; j <= numPartials; j++ {
|
|
keyPartial, _ := options.Serializer.PackPartialKey(kv.Key, j)
|
|
// Check pack partial for sanity
|
|
if j < numPartials {
|
|
if !bytes.HasPrefix(gotKey, keyPartial) || (len(keyPartial) >= len(gotKey)) {
|
|
t.Errorf("%+v should be prefix of %+v\n", keyPartial, gotKey)
|
|
}
|
|
} else {
|
|
if !bytes.Equal(gotKey, keyPartial) {
|
|
t.Errorf("%+v should be equal to %+v\n", keyPartial, gotKey)
|
|
}
|
|
}
|
|
}
|
|
|
|
got, err := options.Serializer.PackValue(kv.Value)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
wantKey, err := hex.DecodeString(records[i][0])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
want, err := hex.DecodeString(records[i][1])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
if !bytes.Equal(gotKey, wantKey) {
|
|
t.Errorf("gotKey: %+v, wantKey: %+v\n", gotKey, wantKey)
|
|
}
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf("got: %+v, want: %+v\n", got, want)
|
|
}
|
|
i++
|
|
}
|
|
|
|
// Test start / stop
|
|
start, err := hex.DecodeString(records[0][0])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
numRecords := i
|
|
// var numRecords = 9
|
|
// if prefix == prefixes.Undo || prefix == prefixes.DBState {
|
|
// numRecords = 1
|
|
// }
|
|
stop, err := hex.DecodeString(records[numRecords-1][0])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
options2 := dbpkg.NewIterateOptions().WithSerializer(options.Serializer).WithStart(start).WithStop(stop).WithIncludeValue(true)
|
|
options2 = options2.WithCfHandle(handle)
|
|
ch2 := dbpkg.IterCF(db, options2)
|
|
i = 0
|
|
for kv := range ch2 {
|
|
got, err := options2.Serializer.PackValue(kv.Value)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
want, err := hex.DecodeString(records[i][1])
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf("got: %+v, want: %+v\n", got, want)
|
|
}
|
|
i++
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSupportAmount(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.SupportAmount)
|
|
testGeneric(filePath, prefixes.SupportAmount, 1)(t)
|
|
}
|
|
|
|
func TestChannelCount(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ChannelCount)
|
|
testGeneric(filePath, prefixes.ChannelCount, 1)(t)
|
|
}
|
|
|
|
func TestDBState(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.DBState)
|
|
testGeneric(filePath, prefixes.DBState, 0)(t)
|
|
}
|
|
|
|
func TestBlockTxs(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.BlockTXs)
|
|
testGeneric(filePath, prefixes.BlockTXs, 1)(t)
|
|
}
|
|
|
|
func TestTxCount(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.TxCount)
|
|
testGeneric(filePath, prefixes.TxCount, 1)(t)
|
|
}
|
|
|
|
func TestTxHash(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.TxHash)
|
|
testGeneric(filePath, prefixes.TxHash, 1)(t)
|
|
}
|
|
|
|
func TestTxNum(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.TxNum)
|
|
testGeneric(filePath, prefixes.TxNum, 1)(t)
|
|
}
|
|
|
|
func TestTx(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.Tx)
|
|
testGeneric(filePath, prefixes.Tx, 1)(t)
|
|
}
|
|
|
|
func TestHashXHistory(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.HashXHistory)
|
|
testGeneric(filePath, prefixes.HashXHistory, 2)(t)
|
|
}
|
|
|
|
func TestUndo(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.Undo)
|
|
testGeneric(filePath, prefixes.Undo, 1)(t)
|
|
}
|
|
|
|
func TestBlockHash(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.BlockHash)
|
|
testGeneric(filePath, prefixes.BlockHash, 1)(t)
|
|
}
|
|
|
|
func TestBlockHeader(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.Header)
|
|
testGeneric(filePath, prefixes.Header, 1)(t)
|
|
}
|
|
|
|
func TestClaimToTXO(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimToTXO)
|
|
testGeneric(filePath, prefixes.ClaimToTXO, 1)(t)
|
|
}
|
|
|
|
func TestTXOToClaim(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.TXOToClaim)
|
|
testGeneric(filePath, prefixes.TXOToClaim, 2)(t)
|
|
}
|
|
|
|
func TestClaimShortID(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimShortIdPrefix)
|
|
testGeneric(filePath, prefixes.ClaimShortIdPrefix, 4)(t)
|
|
}
|
|
|
|
func TestClaimToChannel(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimToChannel)
|
|
testGeneric(filePath, prefixes.ClaimToChannel, 3)(t)
|
|
}
|
|
|
|
func TestChannelToClaim(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ChannelToClaim)
|
|
testGeneric(filePath, prefixes.ChannelToClaim, 4)(t)
|
|
}
|
|
|
|
func TestClaimToSupport(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimToSupport)
|
|
testGeneric(filePath, prefixes.ClaimToSupport, 3)(t)
|
|
}
|
|
|
|
func TestSupportToClaim(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.SupportToClaim)
|
|
testGeneric(filePath, prefixes.SupportToClaim, 2)(t)
|
|
}
|
|
|
|
func TestClaimExpiration(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimExpiration)
|
|
testGeneric(filePath, prefixes.ClaimExpiration, 3)(t)
|
|
}
|
|
|
|
func TestClaimTakeover(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimTakeover)
|
|
testGeneric(filePath, prefixes.ClaimTakeover, 1)(t)
|
|
}
|
|
|
|
func TestPendingActivation(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.PendingActivation)
|
|
testGeneric(filePath, prefixes.PendingActivation, 4)(t)
|
|
}
|
|
|
|
func TestActivated(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ActivatedClaimAndSupport)
|
|
testGeneric(filePath, prefixes.ActivatedClaimAndSupport, 3)(t)
|
|
}
|
|
|
|
func TestActiveAmount(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ActiveAmount)
|
|
testGeneric(filePath, prefixes.ActiveAmount, 5)(t)
|
|
}
|
|
|
|
func TestBidOrder(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.BidOrder)
|
|
testGeneric(filePath, prefixes.BidOrder, 4)(t)
|
|
}
|
|
|
|
func TestRepost(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.Repost)
|
|
testGeneric(filePath, prefixes.Repost, 1)(t)
|
|
}
|
|
|
|
func TestRepostedClaim(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.RepostedClaim)
|
|
testGeneric(filePath, prefixes.RepostedClaim, 3)(t)
|
|
}
|
|
|
|
func TestRepostedCount(t *testing.T) {
|
|
prefix := byte(prefixes.RepostedCount)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{20}, []int{4}, [][3]int{})
|
|
key := &prefixes.RepostedCountKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func TestClaimDiff(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.ClaimDiff)
|
|
testGeneric(filePath, prefixes.ClaimDiff, 1)(t)
|
|
}
|
|
|
|
func TestUTXO(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.UTXO)
|
|
testGeneric(filePath, prefixes.UTXO, 3)(t)
|
|
}
|
|
|
|
func TestHashXUTXO(t *testing.T) {
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefixes.HashXUTXO)
|
|
testGeneric(filePath, prefixes.HashXUTXO, 3)(t)
|
|
}
|
|
|
|
func TestUTXOKey_String(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
prefix []byte
|
|
hashx []byte
|
|
txnum uint32
|
|
nout uint16
|
|
want string
|
|
}{
|
|
{
|
|
name: "Converts to string",
|
|
prefix: []byte("u"),
|
|
hashx: []byte("AAAAAAAAAA"),
|
|
txnum: 0,
|
|
nout: 0,
|
|
want: "*prefixes.UTXOKey(hashX=41414141414141414141, tx_num=0, nout=0)",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
key := &prefixes.UTXOKey{
|
|
Prefix: tt.prefix,
|
|
HashX: tt.hashx,
|
|
TxNum: tt.txnum,
|
|
Nout: tt.nout,
|
|
}
|
|
|
|
got := fmt.Sprint(key)
|
|
log.Println(got)
|
|
if got != tt.want {
|
|
t.Errorf("got: %s, want: %s\n", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTrendingNotifications(t *testing.T) {
|
|
prefix := byte(prefixes.TrendingNotifications)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{4, 20}, []int{8, 8}, [][3]int{})
|
|
key := &prefixes.TrendingNotificationKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func TestMempoolTx(t *testing.T) {
|
|
prefix := byte(prefixes.MempoolTx)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{32}, []int{}, [][3]int{{20, 100, 1}})
|
|
key := &prefixes.MempoolTxKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func TestTouchedHashX(t *testing.T) {
|
|
prefix := byte(prefixes.TouchedHashX)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{4}, []int{}, [][3]int{{1, 5, 11}})
|
|
key := &prefixes.TouchedHashXKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func TestHashXStatus(t *testing.T) {
|
|
prefix := byte(prefixes.HashXStatus)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{20}, []int{32}, [][3]int{})
|
|
key := &prefixes.HashXStatusKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func TestHashXMempoolStatus(t *testing.T) {
|
|
prefix := byte(prefixes.HashXMempoolStatus)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{20}, []int{32}, [][3]int{})
|
|
key := &prefixes.HashXMempoolStatusKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func TestEffectiveAmount(t *testing.T) {
|
|
prefix := byte(prefixes.EffectiveAmount)
|
|
filePath := fmt.Sprintf("../../testdata/%c.csv", prefix)
|
|
//synthesizeTestData([]byte{prefix}, filePath, []int{20}, []int{8, 8}, [][3]int{})
|
|
key := &prefixes.EffectiveAmountKey{}
|
|
testGeneric(filePath, prefix, key.NumFields())(t)
|
|
}
|
|
|
|
func synthesizeTestData(prefix []byte, filePath string, keyFixed, valFixed []int, valVariable [][3]int) {
|
|
file, err := os.OpenFile(filePath, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0644)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer file.Close()
|
|
|
|
records := make([][2][]byte, 0, 20)
|
|
for r := 0; r < 20; r++ {
|
|
key := make([]byte, 0, 1000)
|
|
key = append(key, prefix...)
|
|
val := make([]byte, 0, 1000)
|
|
// Handle fixed columns of key.
|
|
for _, width := range keyFixed {
|
|
v := make([]byte, width)
|
|
rand.Read(v)
|
|
key = append(key, v...)
|
|
}
|
|
// Handle fixed columns of value.
|
|
for _, width := range valFixed {
|
|
v := make([]byte, width)
|
|
rand.Read(v)
|
|
val = append(val, v...)
|
|
}
|
|
// Handle variable length array in value. Each element is "chunk" size.
|
|
for _, w := range valVariable {
|
|
low, high, chunk := w[0], w[1], w[2]
|
|
n, _ := rand.Int(rand.Reader, big.NewInt(int64(high-low)))
|
|
v := make([]byte, chunk*(low+int(n.Int64())))
|
|
rand.Read(v)
|
|
val = append(val, v...)
|
|
}
|
|
records = append(records, [2][]byte{key, val})
|
|
}
|
|
|
|
sort.Slice(records, func(i, j int) bool { return bytes.Compare(records[i][0], records[j][0]) == -1 })
|
|
|
|
wr := csv.NewWriter(file)
|
|
wr.Write([]string{string(prefix), ""}) // column headers
|
|
for _, rec := range records {
|
|
encoded := []string{hex.EncodeToString(rec[0]), hex.EncodeToString(rec[1])}
|
|
err := wr.Write(encoded)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
wr.Flush()
|
|
}
|
|
|
|
// Fuzz tests for various Key and Value types (EXPERIMENTAL)
|
|
|
|
func FuzzTouchedHashXKey(f *testing.F) {
|
|
kvs := []prefixes.TouchedHashXKey{
|
|
{
|
|
Prefix: []byte{prefixes.TouchedHashX},
|
|
Height: 0,
|
|
},
|
|
{
|
|
Prefix: []byte{prefixes.TouchedHashX},
|
|
Height: 1,
|
|
},
|
|
{
|
|
Prefix: []byte{prefixes.TouchedHashX},
|
|
Height: math.MaxUint32,
|
|
},
|
|
}
|
|
|
|
for _, kv := range kvs {
|
|
seed := make([]byte, 0, 200)
|
|
seed = append(seed, kv.PackKey()...)
|
|
f.Add(seed)
|
|
}
|
|
|
|
f.Fuzz(func(t *testing.T, in []byte) {
|
|
t.Logf("testing: %+v", in)
|
|
out := make([]byte, 0, 200)
|
|
var kv prefixes.TouchedHashXKey
|
|
kv.UnpackKey(in)
|
|
out = append(out, kv.PackKey()...)
|
|
if len(in) >= 5 {
|
|
if !bytes.HasPrefix(in, out) {
|
|
t.Fatalf("%v: not equal after round trip: %v", in, out)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func FuzzTouchedHashXValue(f *testing.F) {
|
|
kvs := []prefixes.TouchedHashXValue{
|
|
{
|
|
TouchedHashXs: [][]byte{},
|
|
},
|
|
{
|
|
TouchedHashXs: [][]byte{
|
|
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
|
|
},
|
|
},
|
|
{
|
|
TouchedHashXs: [][]byte{
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
|
|
},
|
|
},
|
|
{
|
|
TouchedHashXs: [][]byte{
|
|
{0xff, 0xff, 2, 3, 4, 5, 6, 7, 8, 9, 10},
|
|
{0, 1, 0xff, 0xff, 4, 5, 6, 7, 8, 9, 10},
|
|
{0, 1, 2, 3, 0xff, 0xff, 6, 7, 8, 9, 10},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, kv := range kvs {
|
|
seed := make([]byte, 0, 200)
|
|
seed = append(seed, kv.PackValue()...)
|
|
f.Add(seed)
|
|
}
|
|
|
|
f.Fuzz(func(t *testing.T, in []byte) {
|
|
t.Logf("testing: %+v", in)
|
|
out := make([]byte, 0, 200)
|
|
var kv prefixes.TouchedHashXValue
|
|
kv.UnpackValue(in)
|
|
out = append(out, kv.PackValue()...)
|
|
if len(in) >= 5 {
|
|
if !bytes.HasPrefix(in, out) {
|
|
t.Fatalf("%v: not equal after round trip: %v", in, out)
|
|
}
|
|
}
|
|
})
|
|
}
|