github.com/okex/exchain@v1.8.0/libs/tendermint/types/block_test.go

package types

import (
	stdbytes "bytes"
	// it is ok to use math/rand here: we do not need a cryptographically secure random
	// number generator here and we can run the tests a bit faster
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"io"
	"math"
	"os"
	"reflect"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/okex/exchain/libs/tendermint/crypto"
	"github.com/okex/exchain/libs/tendermint/crypto/merkle"
	"github.com/okex/exchain/libs/tendermint/crypto/tmhash"
	"github.com/okex/exchain/libs/tendermint/libs/bits"
	"github.com/okex/exchain/libs/tendermint/libs/bytes"
	tmrand "github.com/okex/exchain/libs/tendermint/libs/rand"
	tmtime "github.com/okex/exchain/libs/tendermint/types/time"
	"github.com/okex/exchain/libs/tendermint/version"
)

func TestMain(m *testing.M) {
	RegisterMockEvidences(cdc)

	code := m.Run()
	os.Exit(code)
}

func TestBlockAddEvidence(t *testing.T) {
	txs := []Tx{Tx("foo"), Tx("bar")}
	lastID := makeBlockIDRandom()
	h := int64(3)

	voteSet, valSet, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, time.Now())
	require.NoError(t, err)

	ev := NewMockEvidence(h, time.Now(), 0, valSet.Validators[0].Address)
	evList := []Evidence{ev}

	block := MakeBlock(h, txs, commit, evList)
	require.NotNil(t, block)
	require.Equal(t, 1, len(block.Evidence.Evidence))
	require.NotNil(t, block.EvidenceHash)
}

func TestBlockValidateBasic(t *testing.T) {
	require.Error(t, (*Block)(nil).ValidateBasic())

	txs := []Tx{Tx("foo"), Tx("bar")}
	lastID := makeBlockIDRandom()
	h := int64(3)

	voteSet, valSet, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, time.Now())
	require.NoError(t, err)

	ev := NewMockEvidence(h, time.Now(), 0, valSet.Validators[0].Address)
	evList := []Evidence{ev}

	testCases := []struct {
		testName      string
		malleateBlock func(*Block)
		expErr        bool
	}{
		{"Make Block", func(blk *Block) {}, false},
		{"Make Block w/ proposer Addr", func(blk *Block) { blk.ProposerAddress = valSet.GetProposer().Address }, false},
		{"Negative Height", func(blk *Block) { blk.Height = -1 }, true},
		{"Remove 1/2 the commits", func(blk *Block) {
			blk.LastCommit.Signatures = commit.Signatures[:commit.Size()/2]
			blk.LastCommit.hash = nil // clear hash or change wont be noticed
		}, true},
		{"Remove LastCommitHash", func(blk *Block) { blk.LastCommitHash = []byte("something else") }, true},
		{"Tampered Data", func(blk *Block) {
			blk.Data.Txs[0] = Tx("something else")
			blk.Data.hash = nil // clear hash or change wont be noticed
		}, true},
		{"Tampered DataHash", func(blk *Block) {
			blk.DataHash = tmrand.Bytes(len(blk.DataHash))
		}, true},
		{"Tampered EvidenceHash", func(blk *Block) {
			blk.EvidenceHash = []byte("something else")
		}, true},
	}
	for i, tc := range testCases {
		tc := tc
		i := i
		t.Run(tc.testName, func(t *testing.T) {
			block := MakeBlock(h, txs, commit, evList)
			block.ProposerAddress = valSet.GetProposer().Address
			tc.malleateBlock(block)
			err = block.ValidateBasic()
			assert.Equal(t, tc.expErr, err != nil, "#%d: %v", i, err)
		})
	}
}

func TestBlockHash(t *testing.T) {
	assert.Nil(t, (*Block)(nil).Hash())
	assert.Nil(t, MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil).Hash())
}

func TestBlockMakePartSet(t *testing.T) {
	assert.Nil(t, (*Block)(nil).MakePartSet(2))

	partSet := MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil).MakePartSet(1024)
	assert.NotNil(t, partSet)
	assert.Equal(t, 1, partSet.Total())
}

func TestBlock_MakePartSetByExInfo(t *testing.T) {
	assert.Nil(t, (*Block)(nil).MakePartSetByExInfo(nil))
	block := MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil)
	assert.NotNil(t, block.MakePartSetByExInfo(nil))

	partSet := block.MakePartSetByExInfo(&BlockExInfo{BlockPartSize: 1024})
	assert.NotNil(t, partSet)
	assert.Equal(t, 1, partSet.Total())

	partSet = block.MakePartSetByExInfo(&BlockExInfo{BlockPartSize: 1024, BlockCompressType: 2, BlockCompressFlag: 0})
	assert.NotNil(t, partSet)
	assert.Equal(t, 1, partSet.Total())
}

func TestBlockMakePartSetWithEvidence(t *testing.T) {
	assert.Nil(t, (*Block)(nil).MakePartSet(2))

	lastID := makeBlockIDRandom()
	h := int64(3)

	voteSet, valSet, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, time.Now())
	require.NoError(t, err)

	ev := NewMockEvidence(h, time.Now(), 0, valSet.Validators[0].Address)
	evList := []Evidence{ev}

	partSet := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList).MakePartSet(512)
	assert.NotNil(t, partSet)
	assert.Equal(t, 3, partSet.Total())
}

func TestBlockHashesTo(t *testing.T) {
	assert.False(t, (*Block)(nil).HashesTo(nil))

	lastID := makeBlockIDRandom()
	h := int64(3)
	voteSet, valSet, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, time.Now())
	require.NoError(t, err)

	ev := NewMockEvidence(h, time.Now(), 0, valSet.Validators[0].Address)
	evList := []Evidence{ev}

	block := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList)
	block.ValidatorsHash = valSet.Hash(block.Height)
	assert.False(t, block.HashesTo([]byte{}))
	assert.False(t, block.HashesTo([]byte("something else")))
	assert.True(t, block.HashesTo(block.Hash()))
}

func TestBlockSize(t *testing.T) {
	size := MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil).Size()
	if size <= 0 {
		t.Fatal("Size of the block is zero or negative")
	}
}

func TestBlockString(t *testing.T) {
	assert.Equal(t, "nil-Block", (*Block)(nil).String())
	assert.Equal(t, "nil-Block", (*Block)(nil).StringIndented(""))
	assert.Equal(t, "nil-Block", (*Block)(nil).StringShort())

	block := MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil)
	assert.NotEqual(t, "nil-Block", block.String())
	assert.NotEqual(t, "nil-Block", block.StringIndented(""))
	assert.NotEqual(t, "nil-Block", block.StringShort())
}

func makeBlockIDRandom() BlockID {
	var (
		blockHash   = make([]byte, tmhash.Size)
		partSetHash = make([]byte, tmhash.Size)
	)
	rand.Read(blockHash)   //nolint: gosec
	rand.Read(partSetHash) //nolint: gosec
	return BlockID{blockHash, PartSetHeader{123, partSetHash}}
}

func makeBlockID(hash []byte, partSetSize int, partSetHash []byte) BlockID {
	var (
		h   = make([]byte, tmhash.Size)
		psH = make([]byte, tmhash.Size)
	)
	copy(h, hash)
	copy(psH, partSetHash)
	return BlockID{
		Hash: h,
		PartsHeader: PartSetHeader{
			Total: partSetSize,
			Hash:  psH,
		},
	}
}

var nilBytes []byte

func TestNilHeaderHashDoesntCrash(t *testing.T) {
	assert.Equal(t, []byte((*Header)(nil).Hash()), nilBytes)
	assert.Equal(t, []byte((new(Header)).Hash()), nilBytes)
}

func TestNilDataHashDoesntCrash(t *testing.T) {
	assert.Equal(t, []byte((*Data)(nil).Hash(0)), nilBytes)
	assert.Equal(t, []byte(new(Data).Hash(0)), nilBytes)
}

func TestCommit(t *testing.T) {
	lastID := makeBlockIDRandom()
	h := int64(3)
	voteSet, _, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, time.Now())
	require.NoError(t, err)

	assert.Equal(t, h-1, commit.Height)
	assert.Equal(t, 1, commit.Round)
	assert.Equal(t, PrecommitType, SignedMsgType(commit.Type()))
	if commit.Size() <= 0 {
		t.Fatalf("commit %v has a zero or negative size: %d", commit, commit.Size())
	}

	require.NotNil(t, commit.BitArray())
	assert.Equal(t, bits.NewBitArray(10).Size(), commit.BitArray().Size())

	assert.Equal(t, voteSet.GetByIndex(0), commit.GetByIndex(0))
	assert.True(t, commit.IsCommit())
}

func TestCommitValidateBasic(t *testing.T) {
	testCases := []struct {
		testName       string
		malleateCommit func(*Commit)
		expectErr      bool
	}{
		{"Random Commit", func(com *Commit) {}, false},
		{"Incorrect signature", func(com *Commit) { com.Signatures[0].Signature = []byte{0} }, false},
		{"Incorrect height", func(com *Commit) { com.Height = int64(-100) }, true},
		{"Incorrect round", func(com *Commit) { com.Round = -100 }, true},
	}
	for _, tc := range testCases {
		tc := tc
		t.Run(tc.testName, func(t *testing.T) {
			com := randCommit(time.Now())
			tc.malleateCommit(com)
			assert.Equal(t, tc.expectErr, com.ValidateBasic() != nil, "Validate Basic had an unexpected result")
		})
	}
}

func TestHeaderHash(t *testing.T) {
	testCases := []struct {
		desc       string
		header     *Header
		expectHash bytes.HexBytes
	}{
		{"Generates expected hash", &Header{
			Version:            version.Consensus{Block: 1, App: 2},
			ChainID:            "chainId",
			Height:             3,
			Time:               time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC),
			LastBlockID:        makeBlockID(make([]byte, tmhash.Size), 6, make([]byte, tmhash.Size)),
			LastCommitHash:     tmhash.Sum([]byte("last_commit_hash")),
			DataHash:           tmhash.Sum([]byte("data_hash")),
			ValidatorsHash:     tmhash.Sum([]byte("validators_hash")),
			NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")),
			ConsensusHash:      tmhash.Sum([]byte("consensus_hash")),
			AppHash:            tmhash.Sum([]byte("app_hash")),
			LastResultsHash:    tmhash.Sum([]byte("last_results_hash")),
			EvidenceHash:       tmhash.Sum([]byte("evidence_hash")),
			ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
		}, hexBytesFromString("ABDC78921B18A47EE6BEF5E31637BADB0F3E587E3C0F4DB2D1E93E9FF0533862")},
		{"nil header yields nil", nil, nil},
		{"nil ValidatorsHash yields nil", &Header{
			Version:            version.Consensus{Block: 1, App: 2},
			ChainID:            "chainId",
			Height:             3,
			Time:               time.Date(2019, 10, 13, 16, 14, 44, 0, time.UTC),
			LastBlockID:        makeBlockID(make([]byte, tmhash.Size), 6, make([]byte, tmhash.Size)),
			LastCommitHash:     tmhash.Sum([]byte("last_commit_hash")),
			DataHash:           tmhash.Sum([]byte("data_hash")),
			ValidatorsHash:     nil,
			NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")),
			ConsensusHash:      tmhash.Sum([]byte("consensus_hash")),
			AppHash:            tmhash.Sum([]byte("app_hash")),
			LastResultsHash:    tmhash.Sum([]byte("last_results_hash")),
			EvidenceHash:       tmhash.Sum([]byte("evidence_hash")),
			ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
		}, nil},
	}
	for _, tc := range testCases {
		tc := tc
		t.Run(tc.desc, func(t *testing.T) {
			assert.Equal(t, tc.expectHash, tc.header.Hash())

			// We also make sure that all fields are hashed in struct order, and that all
			// fields in the test struct are non-zero.
			if tc.header != nil && tc.expectHash != nil {
				byteSlices := [][]byte{}
				s := reflect.ValueOf(*tc.header)
				for i := 0; i < s.NumField(); i++ {
					f := s.Field(i)
					assert.False(t, f.IsZero(), "Found zero-valued field %v",
						s.Type().Field(i).Name)
					byteSlices = append(byteSlices, cdcEncode(f.Interface()))
				}
				assert.Equal(t,
					bytes.HexBytes(merkle.SimpleHashFromByteSlices(byteSlices)), tc.header.Hash())
			}
		})
	}
}

func TestMaxHeaderBytes(t *testing.T) {
	// Construct a UTF-8 string of MaxChainIDLen length using the supplementary
	// characters.
	// Each supplementary character takes 4 bytes.
	// http://www.i18nguy.com/unicode/supplementary-test.html
	maxChainID := ""
	for i := 0; i < MaxChainIDLen; i++ {
		maxChainID += "𠜎"
	}

	// time is varint encoded so need to pick the max.
	// year int, month Month, day, hour, min, sec, nsec int, loc *Location
	timestamp := time.Date(math.MaxInt64, 0, 0, 0, 0, 0, math.MaxInt64, time.UTC)

	h := Header{
		Version:            version.Consensus{Block: math.MaxInt64, App: math.MaxInt64},
		ChainID:            maxChainID,
		Height:             math.MaxInt64,
		Time:               timestamp,
		LastBlockID:        makeBlockID(make([]byte, tmhash.Size), math.MaxInt64, make([]byte, tmhash.Size)),
		LastCommitHash:     tmhash.Sum([]byte("last_commit_hash")),
		DataHash:           tmhash.Sum([]byte("data_hash")),
		ValidatorsHash:     tmhash.Sum([]byte("validators_hash")),
		NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")),
		ConsensusHash:      tmhash.Sum([]byte("consensus_hash")),
		AppHash:            tmhash.Sum([]byte("app_hash")),
		LastResultsHash:    tmhash.Sum([]byte("last_results_hash")),
		EvidenceHash:       tmhash.Sum([]byte("evidence_hash")),
		ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
	}

	bz, err := cdc.MarshalBinaryLengthPrefixed(h)
	require.NoError(t, err)

	assert.EqualValues(t, MaxHeaderBytes, int64(len(bz)))
}

func randCommit(now time.Time) *Commit {
	lastID := makeBlockIDRandom()
	h := int64(3)
	voteSet, _, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, now)
	if err != nil {
		panic(err)
	}
	return commit
}

func hexBytesFromString(s string) bytes.HexBytes {
	b, err := hex.DecodeString(s)
	if err != nil {
		panic(err)
	}
	return bytes.HexBytes(b)
}

func TestBlockMaxDataBytes(t *testing.T) {
	testCases := []struct {
		maxBytes      int64
		valsCount     int
		evidenceCount int
		panics        bool
		result        int64
	}{
		0: {-10, 1, 0, true, 0},
		1: {10, 1, 0, true, 0},
		2: {865, 1, 0, true, 0},
		3: {866, 1, 0, false, 0},
		4: {867, 1, 0, false, 1},
	}

	for i, tc := range testCases {
		tc := tc
		if tc.panics {
			assert.Panics(t, func() {
				MaxDataBytes(tc.maxBytes, tc.valsCount, tc.evidenceCount)
			}, "#%v", i)
		} else {
			assert.Equal(t,
				tc.result,
				MaxDataBytes(tc.maxBytes, tc.valsCount, tc.evidenceCount),
				"#%v", i)
		}
	}
}

func TestBlockMaxDataBytesUnknownEvidence(t *testing.T) {
	testCases := []struct {
		maxBytes  int64
		valsCount int
		panics    bool
		result    int64
	}{
		0: {-10, 1, true, 0},
		1: {10, 1, true, 0},
		2: {961, 1, true, 0},
		3: {962, 1, false, 0},
		4: {963, 1, false, 1},
	}

	for i, tc := range testCases {
		tc := tc
		if tc.panics {
			assert.Panics(t, func() {
				MaxDataBytesUnknownEvidence(tc.maxBytes, tc.valsCount)
			}, "#%v", i)
		} else {
			assert.Equal(t,
				tc.result,
				MaxDataBytesUnknownEvidence(tc.maxBytes, tc.valsCount),
				"#%v", i)
		}
	}
}

func TestCommitToVoteSet(t *testing.T) {
	lastID := makeBlockIDRandom()
	h := int64(3)

	voteSet, valSet, vals := randVoteSet(h-1, 1, PrecommitType, 10, 1)
	commit, err := MakeCommit(lastID, h-1, 1, voteSet, vals, time.Now())
	assert.NoError(t, err)

	chainID := voteSet.ChainID()
	voteSet2 := CommitToVoteSet(chainID, commit, valSet)

	for i := 0; i < len(vals); i++ {
		vote1 := voteSet.GetByIndex(i)
		vote2 := voteSet2.GetByIndex(i)
		vote3 := commit.GetVote(i)

		vote1bz := cdc.MustMarshalBinaryBare(vote1)
		vote2bz := cdc.MustMarshalBinaryBare(vote2)
		vote3bz := cdc.MustMarshalBinaryBare(vote3)
		assert.Equal(t, vote1bz, vote2bz)
		assert.Equal(t, vote1bz, vote3bz)
	}
}

func TestCommitToVoteSetWithVotesForNilBlock(t *testing.T) {
	blockID := makeBlockID([]byte("blockhash"), 1000, []byte("partshash"))

	const (
		height = int64(3)
		round  = 0
	)

	type commitVoteTest struct {
		blockIDs      []BlockID
		numVotes      []int // must sum to numValidators
		numValidators int
		valid         bool
	}

	testCases := []commitVoteTest{
		{[]BlockID{blockID, {}}, []int{67, 33}, 100, true},
	}

	for _, tc := range testCases {
		voteSet, valSet, vals := randVoteSet(height-1, round, PrecommitType, tc.numValidators, 1)

		vi := 0
		for n := range tc.blockIDs {
			for i := 0; i < tc.numVotes[n]; i++ {
				pubKey, err := vals[vi].GetPubKey()
				require.NoError(t, err)
				vote := &Vote{
					ValidatorAddress: pubKey.Address(),
					ValidatorIndex:   vi,
					Height:           height - 1,
					Round:            round,
					Type:             PrecommitType,
					BlockID:          tc.blockIDs[n],
					Timestamp:        tmtime.Now(),
				}

				added, err := signAddVote(vals[vi], vote, voteSet)
				assert.NoError(t, err)
				assert.True(t, added)

				vi++
			}
		}

		if tc.valid {
			commit := voteSet.MakeCommit() // panics without > 2/3 valid votes
			assert.NotNil(t, commit)
			err := valSet.VerifyCommit(voteSet.ChainID(), blockID, height-1, commit)
			assert.Nil(t, err)
		} else {
			assert.Panics(t, func() { voteSet.MakeCommit() })
		}
	}
}

func TestSignedHeaderValidateBasic(t *testing.T) {
	commit := randCommit(time.Now())
	chainID := "𠜎"
	timestamp := time.Date(math.MaxInt64, 0, 0, 0, 0, 0, math.MaxInt64, time.UTC)
	h := Header{
		Version:            version.Consensus{Block: math.MaxInt64, App: math.MaxInt64},
		ChainID:            chainID,
		Height:             commit.Height,
		Time:               timestamp,
		LastBlockID:        commit.BlockID,
		LastCommitHash:     commit.Hash(),
		DataHash:           commit.Hash(),
		ValidatorsHash:     commit.Hash(),
		NextValidatorsHash: commit.Hash(),
		ConsensusHash:      commit.Hash(),
		AppHash:            commit.Hash(),
		LastResultsHash:    commit.Hash(),
		EvidenceHash:       commit.Hash(),
		ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
	}

	validSignedHeader := SignedHeader{Header: &h, Commit: commit}
	validSignedHeader.Commit.BlockID.Hash = validSignedHeader.Hash()
	invalidSignedHeader := SignedHeader{}

	testCases := []struct {
		testName  string
		shHeader  *Header
		shCommit  *Commit
		expectErr bool
	}{
		{"Valid Signed Header", validSignedHeader.Header, validSignedHeader.Commit, false},
		{"Invalid Signed Header", invalidSignedHeader.Header, validSignedHeader.Commit, true},
		{"Invalid Signed Header", validSignedHeader.Header, invalidSignedHeader.Commit, true},
	}

	for _, tc := range testCases {
		tc := tc
		t.Run(tc.testName, func(t *testing.T) {
			sh := SignedHeader{
				Header: tc.shHeader,
				Commit: tc.shCommit,
			}
			assert.Equal(
				t,
				tc.expectErr,
				sh.ValidateBasic(validSignedHeader.Header.ChainID) != nil,
				"Validate Basic had an unexpected result",
			)
		})
	}
}

func TestBlockIDValidateBasic(t *testing.T) {
	validBlockID := BlockID{
		Hash: bytes.HexBytes{},
		PartsHeader: PartSetHeader{
			Total: 1,
			Hash:  bytes.HexBytes{},
		},
	}

	invalidBlockID := BlockID{
		Hash: []byte{0},
		PartsHeader: PartSetHeader{
			Total: -1,
			Hash:  bytes.HexBytes{},
		},
	}

	testCases := []struct {
		testName           string
		blockIDHash        bytes.HexBytes
		blockIDPartsHeader PartSetHeader
		expectErr          bool
	}{
		{"Valid BlockID", validBlockID.Hash, validBlockID.PartsHeader, false},
		{"Invalid BlockID", invalidBlockID.Hash, validBlockID.PartsHeader, true},
		{"Invalid BlockID", validBlockID.Hash, invalidBlockID.PartsHeader, true},
	}

	for _, tc := range testCases {
		tc := tc
		t.Run(tc.testName, func(t *testing.T) {
			blockID := BlockID{
				Hash:        tc.blockIDHash,
				PartsHeader: tc.blockIDPartsHeader,
			}
			assert.Equal(t, tc.expectErr, blockID.ValidateBasic() != nil, "Validate Basic had an unexpected result")
		})
	}
}

func makeRandHeader() Header {
	chainID := "test"
	t := time.Now()
	height := tmrand.Int63()
	randBytes := tmrand.Bytes(tmhash.Size)
	randAddress := tmrand.Bytes(crypto.AddressSize)
	h := Header{
		Version:            version.Consensus{Block: 1, App: 1},
		ChainID:            chainID,
		Height:             height,
		Time:               t,
		LastBlockID:        BlockID{},
		LastCommitHash:     randBytes,
		DataHash:           randBytes,
		ValidatorsHash:     randBytes,
		NextValidatorsHash: randBytes,
		ConsensusHash:      randBytes,
		AppHash:            randBytes,

		LastResultsHash: randBytes,

		EvidenceHash:    randBytes,
		ProposerAddress: randAddress,
	}

	return h
}

func TestHeaderProto(t *testing.T) {
	h1 := makeRandHeader()
	tc := []struct {
		msg     string
		h1      *Header
		expPass bool
	}{
		{"success", &h1, true},
		{"failure empty Header", &Header{}, false},
	}

	for _, tt := range tc {
		tt := tt
		t.Run(tt.msg, func(t *testing.T) {
			pb := tt.h1.ToProto()
			h, err := HeaderFromProto(pb)
			if tt.expPass {
				require.NoError(t, err, tt.msg)
				require.Equal(t, tt.h1, &h, tt.msg)
			} else {
				require.Error(t, err, tt.msg)
			}

		})
	}
}

func TestBlockIDProtoBuf(t *testing.T) {
	blockID := makeBlockID([]byte("hash"), 2, []byte("part_set_hash"))
	testCases := []struct {
		msg     string
		bid1    *BlockID
		expPass bool
	}{
		{"success", &blockID, true},
		{"success empty", &BlockID{}, true},
		{"failure BlockID nil", nil, false},
	}
	for _, tc := range testCases {
		protoBlockID := tc.bid1.ToProto()

		bi, err := BlockIDFromProto(&protoBlockID)
		if tc.expPass {
			require.NoError(t, err)
			require.Equal(t, tc.bid1, bi, tc.msg)
		} else {
			require.NotEqual(t, tc.bid1, bi, tc.msg)
		}
	}
}

func TestSignedHeaderProtoBuf(t *testing.T) {
	commit := randCommit(time.Now())
	h := makeRandHeader()

	sh := SignedHeader{Header: &h, Commit: commit}

	testCases := []struct {
		msg     string
		sh1     *SignedHeader
		expPass bool
	}{
		{"empty SignedHeader 2", &SignedHeader{}, true},
		{"success", &sh, true},
		{"failure nil", nil, false},
	}
	for _, tc := range testCases {
		protoSignedHeader := tc.sh1.ToProto()

		sh, err := SignedHeaderFromProto(protoSignedHeader)

		if tc.expPass {
			require.NoError(t, err, tc.msg)
			require.Equal(t, tc.sh1, sh, tc.msg)
		} else {
			require.Error(t, err, tc.msg)
		}
	}
}

func TestCommitProtoBuf(t *testing.T) {
	commit := randCommit(time.Now())

	testCases := []struct {
		msg     string
		c1      *Commit
		expPass bool
	}{
		{"success", commit, true},
		// Empty value sets signatures to nil, signatures should not be nillable
		{"empty commit", &Commit{Signatures: []CommitSig{}}, true},
		{"fail Commit nil", nil, false},
	}
	for _, tc := range testCases {
		tc := tc
		protoCommit := tc.c1.ToProto()

		c, err := CommitFromProto(protoCommit)

		if tc.expPass {
			require.NoError(t, err, tc.msg)
			require.Equal(t, tc.c1, c, tc.msg)
		} else {
			require.Error(t, err, tc.msg)
		}
	}
}

var blockIDTestCases = []BlockID{
	{},
	{Hash: []byte{}},
	{[]byte("hashhashhashhashhashhash"), PartSetHeader{}},
	{[]byte("hashhashhashhashhashhash"), PartSetHeader{Total: 1, Hash: []byte("part_set_hash")}},
}

func TestBlockIDAmino(t *testing.T) {
	for _, tc := range blockIDTestCases {
		bz, err := cdc.MarshalBinaryBare(tc)
		require.NoError(t, err)

		var tc2 BlockID
		err = cdc.UnmarshalBinaryBare(bz, &tc2)
		require.NoError(t, err)

		var tc3 BlockID
		err = tc3.UnmarshalFromAmino(cdc, bz)
		require.NoError(t, err)

		require.EqualValues(t, tc2, tc3)
		require.EqualValues(t, len(bz), tc.AminoSize(cdc))
	}
}

var headerAminoTestCases = []Header{
	{},
	{Version: version.Consensus{Block: 1, App: 1}},
	{ChainID: "ChainID"},
	{Height: 1},
	{Height: math.MaxInt64},
	{Height: math.MinInt64},
	{Time: time.Now()},
	{LastBlockID: BlockID{[]byte("Hash"), PartSetHeader{1, []byte("Hash")}}},
	{LastCommitHash: []byte("LastCommitHash")},
	{DataHash: []byte("DataHash")},
	{ValidatorsHash: []byte("ValidatorsHash")},
	{NextValidatorsHash: []byte("NextValidatorsHash")},
	{ConsensusHash: []byte("ConsensusHash")},
	{AppHash: []byte("AppHash")},
	{LastResultsHash: []byte("LastResultsHash")},
	{EvidenceHash: []byte("EvidenceHash")},
	{ProposerAddress: []byte("ProposerAddress")},
}

func TestHeaderAmino(t *testing.T) {
	for _, header := range headerAminoTestCases {
		expectData, err := cdc.MarshalBinaryBare(header)
		require.NoError(t, err)

		require.Equal(t, len(expectData), header.AminoSize(cdc))

		var expectValue Header
		err = cdc.UnmarshalBinaryBare(expectData, &expectValue)
		require.NoError(t, err)

		var actualValue Header
		err = actualValue.UnmarshalFromAmino(cdc, expectData)
		require.NoError(t, err)

		require.EqualValues(t, expectValue, actualValue)
	}
}

func BenchmarkHeaderAminoUnmarshal(b *testing.B) {
	testData := make([][]byte, len(headerAminoTestCases))
	for i, header := range headerAminoTestCases {
		data, err := cdc.MarshalBinaryBare(header)
		require.NoError(b, err)
		testData[i] = data
	}
	b.ResetTimer()
	b.Run("amino", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			for _, data := range testData {
				var header Header
				err := cdc.UnmarshalBinaryBare(data, &header)
				if err != nil {
					b.Fatal(err)
				}
			}
		}
	})
	b.Run("unmarshaller", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			for _, data := range testData {
				var header Header
				err := header.UnmarshalFromAmino(cdc, data)
				if err != nil {
					b.Fatal(err)
				}
			}
		}
	})
}

func TestDataAmino(t *testing.T) {
	var testCases = []Data{
		{},
		{Txs: []Tx{}},
		{Txs: []Tx{{}}},
		{Txs: []Tx{nil}},
		{Txs: []Tx{{}, []byte("tx1"), []byte("tx2"), nil}},
		{hash: []byte("hash")},
	}

	for _, d := range testCases {
		expectData, err := cdc.MarshalBinaryBare(d)
		require.NoError(t, err)

		require.Equal(t, len(expectData), d.AminoSize(cdc))

		var expectValue Data
		err = cdc.UnmarshalBinaryBare(expectData, &expectValue)
		require.NoError(t, err)

		var actualValue Data
		err = actualValue.UnmarshalFromAmino(cdc, expectData)
		require.NoError(t, err)

		require.EqualValues(t, expectValue, actualValue)
	}
}

var commitSigAminoTestCases = []CommitSig{
	{},
	{125, []byte("ValidatorAddress"), time.Now(), []byte("Signature")},
	{math.MaxUint8, []byte(""), time.Now(), []byte("")},
}

func TestCommitSigAmino(t *testing.T) {
	for _, cs := range commitSigAminoTestCases {
		expectData, err := cdc.MarshalBinaryBare(cs)
		require.NoError(t, err)

		require.Equal(t, len(expectData), cs.AminoSize(cdc))

		var expectValue CommitSig
		err = cdc.UnmarshalBinaryBare(expectData, &expectValue)
		require.NoError(t, err)

		var actualValue CommitSig
		err = actualValue.UnmarshalFromAmino(cdc, expectData)

		require.NoError(t, err)

		require.EqualValues(t, expectValue, actualValue)
	}
}

var commitAminoTestCases = []Commit{
	{},
	{
		Height:     123456,
		Round:      10,
		BlockID:    BlockID{Hash: []byte("hash"), PartsHeader: PartSetHeader{Total: 123, Hash: []byte("hash")}},
		Signatures: commitSigAminoTestCases,
	},
	{
		Height:     math.MaxInt64,
		Round:      math.MaxInt,
		Signatures: []CommitSig{},
	},
	{
		Height: math.MinInt64,
		Round:  math.MinInt,
	},
}

func TestCommitAmino(t *testing.T) {
	for _, commit := range commitAminoTestCases {
		expectData, err := cdc.MarshalBinaryBare(commit)
		require.NoError(t, err)

		require.Equal(t, len(expectData), commit.AminoSize(cdc))

		var expectValue Commit
		err = cdc.UnmarshalBinaryBare(expectData, &expectValue)
		require.NoError(t, err)

		var actualValue Commit
		err = actualValue.UnmarshalFromAmino(cdc, expectData)
		require.NoError(t, err)

		require.EqualValues(t, expectValue, actualValue)
	}
}

func TestEvidenceDataAmino(t *testing.T) {
	evidenceDataAminoTestCases := []EvidenceData{
		{},
		{[]Evidence{}, []byte("hash")},
		{Evidence: []Evidence{nil, nil}},
		{
			Evidence: []Evidence{
				nil,
				&DuplicateVoteEvidence{VoteA: nil},
				MockRandomEvidence{},
				MockEvidence{},
			},
		},
	}
	for _, evi := range evidenceDataAminoTestCases {
		expectData, err := cdc.MarshalBinaryBare(evi)
		require.NoError(t, err)

		require.Equal(t, len(expectData), evi.AminoSize(cdc))

		var expectValue EvidenceData
		err = cdc.UnmarshalBinaryBare(expectData, &expectValue)
		require.NoError(t, err)

		var actualValue EvidenceData
		err = actualValue.UnmarshalFromAmino(cdc, expectData)
		require.NoError(t, err)

		require.EqualValues(t, expectValue, actualValue)
	}
}

var blockAminoTestCases = []Block{
	{},
	{
		Header: Header{LastBlockID: BlockID{[]byte("Hash"), PartSetHeader{1, []byte("Hash")}}},
		Data:   Data{Txs: []Tx{{}, []byte("tx1"), []byte("tx2"), nil}},
		Evidence: EvidenceData{
			Evidence: []Evidence{
				&DuplicateVoteEvidence{VoteA: &Vote{
					0, 12345, 123,
					BlockID{[]byte("hash"), PartSetHeader{8, []byte("hash")}},
					time.Now(),
					[]byte("ValidatorAddress"),
					23,
					[]byte("Signature"), false,
				}},
			},
		},
		LastCommit: &Commit{
			Height:     123456,
			Round:      10,
			BlockID:    BlockID{Hash: []byte("hash"), PartsHeader: PartSetHeader{Total: 123, Hash: []byte("hash")}},
			Signatures: commitSigAminoTestCases,
		},
	},
	{
		LastCommit: &Commit{},
	},
}

func TestBlockAmino(t *testing.T) {
	for _, block := range blockAminoTestCases {
		expectData, err := cdc.MarshalBinaryBare(block)
		require.NoError(t, err)

		require.Equal(t, len(expectData), block.AminoSize(cdc))

		var expectValue Block
		err = cdc.UnmarshalBinaryBare(expectData, &expectValue)
		require.NoError(t, err)

		var actualValue Block
		err = actualValue.UnmarshalFromAmino(cdc, expectData)
		require.NoError(t, err)

		require.EqualValues(t, expectValue, actualValue)
	}
}

func BenchmarkBlockAminoUnmarshal(b *testing.B) {
	testData := make([][]byte, len(blockAminoTestCases))
	for i, block := range blockAminoTestCases {
		data, err := cdc.MarshalBinaryBare(block)
		require.NoError(b, err)
		testData[i] = data
	}
	b.ResetTimer()
	b.Run("amino", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			for _, d := range testData {
				var block Block
				err := cdc.UnmarshalBinaryBare(d, &block)
				if err != nil {
					b.Fatal(err)
				}
			}
		}
	})
	b.Run("unmarshaller", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			for _, d := range testData {
				var block Block
				err := block.UnmarshalFromAmino(cdc, d)
				if err != nil {
					b.Fatal(err)
				}
			}
		}
	})
}

func Test_compressBlock(t *testing.T) {
	bzShort := []byte("short bz value")
	bzLarge := make([]byte, BlockCompressThreshold+1)
	type args struct {
		bz                  []byte
		oldBlockComressType int
		before              func()
	}
	tests := []struct {
		name string
		args args
		want []byte
		ret  func(got []byte) bool
	}{
		{"block compress type zero", args{bz: bzShort, oldBlockComressType: BlockCompressType, before: func() {}}, bzShort, func([]byte) bool { return true }},
		{"block compress with short length", args{bz: bzShort, oldBlockComressType: BlockCompressType, before: func() { BlockCompressType = 1 }}, bzShort, func([]byte) bool { return true }},
		{"block compress with large length", args{bz: bzLarge, oldBlockComressType: BlockCompressType, before: func() { BlockCompressType = 1 }}, nil, func(got []byte) bool { return len(got) < len(bzLarge) }},
		{"block compress with unknown compress type", args{bz: bzLarge, oldBlockComressType: BlockCompressType, before: func() { BlockCompressType = 9 }}, nil, func(got []byte) bool { return len(got) > len(bzLarge) }},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.args.before()
			got := compressBlock(tt.args.bz, BlockCompressType, 0)
			assert.NotNil(t, got)
			assert.True(t, tt.ret(got))
			BlockCompressType = tt.args.oldBlockComressType
		})
	}
}

func TestUncompressBlockFromReader(t *testing.T) {
	unCompressedContent, _ := cdc.MarshalBinaryBare([]byte("this is unCompressed content"))
	unCompressedReader := stdbytes.NewReader(unCompressedContent)

	compressedBytes := make([]byte, BlockCompressThreshold+1)
	content, _ := cdc.MarshalBinaryBare(compressedBytes)
	oldCompressType := BlockCompressType
	BlockCompressType = 1
	compressedContent := compressBlock(content, BlockCompressType, 0)
	compressedReader := stdbytes.NewReader(compressedContent)

	type args struct {
		pbpReader io.Reader
	}
	tests := []struct {
		name    string
		args    args
		want    []byte
		wantErr assert.ErrorAssertionFunc
	}{
		{"uncompressed from not compressed reader", args{pbpReader: unCompressedReader}, unCompressedContent, assert.NoError},
		{"uncompressed from compressed reader", args{pbpReader: compressedReader}, content, assert.NoError},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := UncompressBlockFromReader(tt.args.pbpReader)
			if !tt.wantErr(t, err, fmt.Sprintf("UncompressBlockFromReader(%v)", tt.args.pbpReader)) {
				return
			}
			gotBytes := make([]byte, BlockCompressThreshold+BlockCompressThreshold)
			n, _ := got.Read(gotBytes)
			assert.Equalf(t, tt.want, gotBytes[:n], "UncompressBlockFromReader(%v)", tt.args.pbpReader)
		})
	}
	BlockCompressType = oldCompressType
}

func TestUncompressBlockFromBytes(t *testing.T) {
	unCompressedContent, _ := cdc.MarshalBinaryBare([]byte("this is unCompressed content"))

	compressedBytes := make([]byte, BlockCompressThreshold+1)
	content, _ := cdc.MarshalBinaryBare(compressedBytes)
	BlockCompressType = 1
	compressedContent := compressBlock(content, BlockCompressType, 0)

	type args struct {
		payload []byte
	}
	tests := []struct {
		name             string
		args             args
		wantRes          []byte
		wantCompressType int
		wantErr          assert.ErrorAssertionFunc
	}{
		{"uncompressed from not compressed bytes", args{payload: unCompressedContent}, unCompressedContent, 0, assert.NoError},
		{"uncompressed from compressed bytes", args{payload: compressedContent}, content, 1, assert.NoError},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotRes, gotCompressSign, err := UncompressBlockFromBytes(tt.args.payload)
			if !tt.wantErr(t, err, fmt.Sprintf("UncompressBlockFromBytes(%v)", tt.args.payload)) {
				return
			}
			gotCompressType := gotCompressSign / CompressDividing
			assert.Equalf(t, tt.wantRes, gotRes, "UncompressBlockFromBytes(%v)", tt.args.payload)
			assert.Equalf(t, tt.wantCompressType, gotCompressType, "UncompressBlockFromBytes(%v)", tt.args.payload)
		})
	}
}