node_gen_test.go

package trie

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"bytes"
	"math/rand"
	"testing"
	"time"

	"github.com/annchain/OG/types"
	"github.com/tinylib/msgp/msgp"
)

var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func newFullNode() *FullNode {
	rand.Seed(time.Now().UnixNano())

	fn := FullNode{}
	for i := range fn.Children {
		flag := rand.Intn(3)
		if flag == 0 {
			continue
		} else if flag == 1 {
			fn.Children[i] = newHashNode()
		} else {
			fn.Children[i] = newValueNode()
		}
	}
	return &fn
}

func newShortNode() *ShortNode {
	rand.Seed(time.Now().UnixNano())

	sn := ShortNode{}
	flag := rand.Intn(3)
	if flag == 0 {
		return &sn
	} else if flag == 1 {
		sn.Val = newHashNode()
	} else {
		sn.Val = newValueNode()
	}
	sn.Key = []byte("key")
	return &sn
}

func newHashNode() HashNode {
	rand.Seed(time.Now().UnixNano())

	sr := make([]rune, 10)
	for i := range sr {
		sr[i] = letterRunes[rand.Intn(len(letterRunes))]
	}
	seedstr := string(sr)
	return HashNode(common.HexToHash(seedstr).ToBytes())
}

func newValueNode() ValueNode {
	rand.Seed(time.Now().UnixNano())

	sr := make([]rune, rand.Intn(50))
	for i := range sr {
		sr[i] = letterRunes[rand.Intn(len(letterRunes))]
	}
	seedstr := string(sr)
	return ValueNode([]byte(seedstr))
}

func TestMarshalUnmarshalFullNode(t *testing.T) {
	v := FullNode{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}

	vnew := newFullNode()
	bts, err = vnew.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	var fn FullNode
	left, err = fn.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

}

func BenchmarkMarshalMsgFullNode(b *testing.B) {
	v := FullNode{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgFullNode(b *testing.B) {
	v := FullNode{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

func BenchmarkUnmarshalFullNode(b *testing.B) {
	v := FullNode{}
	bts, _ := v.MarshalMsg(nil)
	b.ReportAllocs()
	b.SetBytes(int64(len(bts)))
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := v.UnmarshalMsg(bts)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestEncodeDecodeFullNode(t *testing.T) {
	v := FullNode{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Logf("WARNING: Msgsize() for %v is inaccurate", v)
	}

	vn := FullNode{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeFullNode(b *testing.B) {
	v := FullNode{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeFullNode(b *testing.B) {
	v := FullNode{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestMarshalUnmarshalShortNode(t *testing.T) {
	v := ShortNode{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}

	vnew := newShortNode()
	bts, err = vnew.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	var sn ShortNode
	left, err = sn.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}
	if string(vnew.Key) != string(sn.Key) {
		t.Errorf("vnew and sn not the same, vnew key: %s, sn key: %s", string(vnew.Key), string(sn.Key))
	}

}

func BenchmarkMarshalMsgShortNode(b *testing.B) {
	v := ShortNode{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgShortNode(b *testing.B) {
	v := ShortNode{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

func BenchmarkUnmarshalShortNode(b *testing.B) {
	v := ShortNode{}
	bts, _ := v.MarshalMsg(nil)
	b.ReportAllocs()
	b.SetBytes(int64(len(bts)))
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := v.UnmarshalMsg(bts)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestEncodeDecodeShortNode(t *testing.T) {
	v := ShortNode{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Logf("WARNING: Msgsize() for %v is inaccurate", v)
	}

	vn := ShortNode{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeShortNode(b *testing.B) {
	v := ShortNode{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeShortNode(b *testing.B) {
	v := ShortNode{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}