mirror of
https://github.com/fluencelabs/tendermint
synced 2025-04-25 06:42:16 +00:00
use nolint label instead of commenting
This commit is contained in:
Anton Kaliaev
parent
23314daee4
commit
6941d1bb35
@ -364,22 +364,23 @@ func (pool *BlockPool) sendError(err error, peerID p2p.ID) {
|
||||
}
|
||||
|
||||
// for debugging purposes
|
||||
// func (pool *BlockPool) debug() string {
|
||||
// pool.mtx.Lock()
|
||||
// defer pool.mtx.Unlock()
|
||||
//nolint:unused
|
||||
func (pool *BlockPool) debug() string {
|
||||
pool.mtx.Lock()
|
||||
defer pool.mtx.Unlock()
|
||||
|
||||
// str := ""
|
||||
// nextHeight := pool.height + pool.requestersLen()
|
||||
// for h := pool.height; h < nextHeight; h++ {
|
||||
// if pool.requesters[h] == nil {
|
||||
// str += fmt.Sprintf("H(%v):X ", h)
|
||||
// } else {
|
||||
// str += fmt.Sprintf("H(%v):", h)
|
||||
// str += fmt.Sprintf("B?(%v) ", pool.requesters[h].block != nil)
|
||||
// }
|
||||
// }
|
||||
// return str
|
||||
// }
|
||||
str := ""
|
||||
nextHeight := pool.height + pool.requestersLen()
|
||||
for h := pool.height; h < nextHeight; h++ {
|
||||
if pool.requesters[h] == nil {
|
||||
str += fmt.Sprintf("H(%v):X ", h)
|
||||
} else {
|
||||
str += fmt.Sprintf("H(%v):", h)
|
||||
str += fmt.Sprintf("B?(%v) ", pool.requesters[h].block != nil)
|
||||
}
|
||||
}
|
||||
return str
|
||||
}
|
||||
|
||||
//-------------------------------------
|
||||
|
||||
|
||||
@ -378,36 +378,6 @@ func ensureNewEvent(
|
||||
}
|
||||
}
|
||||
|
||||
// func ensureNewRoundStep(stepCh <-chan interface{}, height int64, round int) {
|
||||
// ensureNewEvent(
|
||||
// stepCh,
|
||||
// height,
|
||||
// round,
|
||||
// ensureTimeout,
|
||||
// "Timeout expired while waiting for NewStep event")
|
||||
// }
|
||||
|
||||
// func ensureNewVote(voteCh <-chan interface{}, height int64, round int) {
|
||||
// select {
|
||||
// case <-time.After(ensureTimeout):
|
||||
// break
|
||||
// case v := <-voteCh:
|
||||
// edv, ok := v.(types.EventDataVote)
|
||||
// if !ok {
|
||||
// panic(fmt.Sprintf("expected a *types.Vote, "+
|
||||
// "got %v. wrong subscription channel?",
|
||||
// reflect.TypeOf(v)))
|
||||
// }
|
||||
// vote := edv.Vote
|
||||
// if vote.Height != height {
|
||||
// panic(fmt.Sprintf("expected height %v, got %v", height, vote.Height))
|
||||
// }
|
||||
// if vote.Round != round {
|
||||
// panic(fmt.Sprintf("expected round %v, got %v", round, vote.Round))
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
func ensureNewRound(roundCh <-chan interface{}, height int64, round int) {
|
||||
select {
|
||||
case <-time.After(ensureTimeout):
|
||||
|
||||
@ -26,17 +26,18 @@ func NewDominoOp(key, input, output string) DominoOp {
|
||||
}
|
||||
}
|
||||
|
||||
// func DominoOpDecoder(pop ProofOp) (ProofOperator, error) {
|
||||
// if pop.Type != ProofOpDomino {
|
||||
// panic("unexpected proof op type")
|
||||
// }
|
||||
// var op DominoOp // a bit strange as we'll discard this, but it works.
|
||||
// err := amino.UnmarshalBinaryLengthPrefixed(pop.Data, &op)
|
||||
// if err != nil {
|
||||
// return nil, cmn.ErrorWrap(err, "decoding ProofOp.Data into SimpleValueOp")
|
||||
// }
|
||||
// return NewDominoOp(string(pop.Key), op.Input, op.Output), nil
|
||||
// }
|
||||
//nolint:unused
|
||||
func DominoOpDecoder(pop ProofOp) (ProofOperator, error) {
|
||||
if pop.Type != ProofOpDomino {
|
||||
panic("unexpected proof op type")
|
||||
}
|
||||
var op DominoOp // a bit strange as we'll discard this, but it works.
|
||||
err := amino.UnmarshalBinaryLengthPrefixed(pop.Data, &op)
|
||||
if err != nil {
|
||||
return nil, cmn.ErrorWrap(err, "decoding ProofOp.Data into SimpleValueOp")
|
||||
}
|
||||
return NewDominoOp(string(pop.Key), op.Input, op.Output), nil
|
||||
}
|
||||
|
||||
func (dop DominoOp) ProofOp() ProofOp {
|
||||
bz := amino.MustMarshalBinaryLengthPrefixed(dop)
|
||||
|
||||
@ -2,6 +2,8 @@ package clist
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"runtime"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
@ -65,98 +67,100 @@ func TestSmall(t *testing.T) {
|
||||
|
||||
// This test is quite hacky because it relies on SetFinalizer
|
||||
// which isn't guaranteed to run at all.
|
||||
//func TestGCFifo(t *testing.T) {
|
||||
// if runtime.GOARCH != "amd64" {
|
||||
// t.Skipf("Skipping on non-amd64 machine")
|
||||
// }
|
||||
//nolint:unused,deadcode
|
||||
func _TestGCFifo(t *testing.T) {
|
||||
if runtime.GOARCH != "amd64" {
|
||||
t.Skipf("Skipping on non-amd64 machine")
|
||||
}
|
||||
|
||||
// const numElements = 1000000
|
||||
// l := New()
|
||||
// gcCount := new(uint64)
|
||||
const numElements = 1000000
|
||||
l := New()
|
||||
gcCount := new(uint64)
|
||||
|
||||
// // SetFinalizer doesn't work well with circular structures,
|
||||
// // so we construct a trivial non-circular structure to
|
||||
// // track.
|
||||
// type value struct {
|
||||
// Int int
|
||||
// }
|
||||
// done := make(chan struct{})
|
||||
// SetFinalizer doesn't work well with circular structures,
|
||||
// so we construct a trivial non-circular structure to
|
||||
// track.
|
||||
type value struct {
|
||||
Int int
|
||||
}
|
||||
done := make(chan struct{})
|
||||
|
||||
// for i := 0; i < numElements; i++ {
|
||||
// v := new(value)
|
||||
// v.Int = i
|
||||
// l.PushBack(v)
|
||||
// runtime.SetFinalizer(v, func(v *value) {
|
||||
// atomic.AddUint64(gcCount, 1)
|
||||
// })
|
||||
// }
|
||||
for i := 0; i < numElements; i++ {
|
||||
v := new(value)
|
||||
v.Int = i
|
||||
l.PushBack(v)
|
||||
runtime.SetFinalizer(v, func(v *value) {
|
||||
atomic.AddUint64(gcCount, 1)
|
||||
})
|
||||
}
|
||||
|
||||
// for el := l.Front(); el != nil; {
|
||||
// l.Remove(el)
|
||||
// //oldEl := el
|
||||
// el = el.Next()
|
||||
// //oldEl.DetachPrev()
|
||||
// //oldEl.DetachNext()
|
||||
// }
|
||||
for el := l.Front(); el != nil; {
|
||||
l.Remove(el)
|
||||
//oldEl := el
|
||||
el = el.Next()
|
||||
//oldEl.DetachPrev()
|
||||
//oldEl.DetachNext()
|
||||
}
|
||||
|
||||
// runtime.GC()
|
||||
// time.Sleep(time.Second * 3)
|
||||
// runtime.GC()
|
||||
// time.Sleep(time.Second * 3)
|
||||
// _ = done
|
||||
runtime.GC()
|
||||
time.Sleep(time.Second * 3)
|
||||
runtime.GC()
|
||||
time.Sleep(time.Second * 3)
|
||||
_ = done
|
||||
|
||||
// if *gcCount != numElements {
|
||||
// t.Errorf("Expected gcCount to be %v, got %v", numElements,
|
||||
// *gcCount)
|
||||
// }
|
||||
//}
|
||||
if *gcCount != numElements {
|
||||
t.Errorf("Expected gcCount to be %v, got %v", numElements,
|
||||
*gcCount)
|
||||
}
|
||||
}
|
||||
|
||||
// This test is quite hacky because it relies on SetFinalizer
|
||||
// which isn't guaranteed to run at all.
|
||||
// func TestGCRandom(t *testing.T) {
|
||||
// if runtime.GOARCH != "amd64" {
|
||||
// t.Skipf("Skipping on non-amd64 machine")
|
||||
// }
|
||||
//nolint:unused,deadcode
|
||||
func TestGCRandom(t *testing.T) {
|
||||
if runtime.GOARCH != "amd64" {
|
||||
t.Skipf("Skipping on non-amd64 machine")
|
||||
}
|
||||
|
||||
// const numElements = 1000000
|
||||
// l := New()
|
||||
// gcCount := 0
|
||||
const numElements = 1000000
|
||||
l := New()
|
||||
gcCount := 0
|
||||
|
||||
// // SetFinalizer doesn't work well with circular structures,
|
||||
// // so we construct a trivial non-circular structure to
|
||||
// // track.
|
||||
// type value struct {
|
||||
// Int int
|
||||
// }
|
||||
// SetFinalizer doesn't work well with circular structures,
|
||||
// so we construct a trivial non-circular structure to
|
||||
// track.
|
||||
type value struct {
|
||||
Int int
|
||||
}
|
||||
|
||||
// for i := 0; i < numElements; i++ {
|
||||
// v := new(value)
|
||||
// v.Int = i
|
||||
// l.PushBack(v)
|
||||
// runtime.SetFinalizer(v, func(v *value) {
|
||||
// gcCount++
|
||||
// })
|
||||
// }
|
||||
for i := 0; i < numElements; i++ {
|
||||
v := new(value)
|
||||
v.Int = i
|
||||
l.PushBack(v)
|
||||
runtime.SetFinalizer(v, func(v *value) {
|
||||
gcCount++
|
||||
})
|
||||
}
|
||||
|
||||
// els := make([]*CElement, 0, numElements)
|
||||
// for el := l.Front(); el != nil; el = el.Next() {
|
||||
// els = append(els, el)
|
||||
// }
|
||||
els := make([]*CElement, 0, numElements)
|
||||
for el := l.Front(); el != nil; el = el.Next() {
|
||||
els = append(els, el)
|
||||
}
|
||||
|
||||
// for _, i := range cmn.RandPerm(numElements) {
|
||||
// el := els[i]
|
||||
// l.Remove(el)
|
||||
// _ = el.Next()
|
||||
// }
|
||||
for _, i := range cmn.RandPerm(numElements) {
|
||||
el := els[i]
|
||||
l.Remove(el)
|
||||
_ = el.Next()
|
||||
}
|
||||
|
||||
// runtime.GC()
|
||||
// time.Sleep(time.Second * 3)
|
||||
runtime.GC()
|
||||
time.Sleep(time.Second * 3)
|
||||
|
||||
// if gcCount != numElements {
|
||||
// t.Errorf("Expected gcCount to be %v, got %v", numElements,
|
||||
// gcCount)
|
||||
// }
|
||||
// }
|
||||
if gcCount != numElements {
|
||||
t.Errorf("Expected gcCount to be %v, got %v", numElements,
|
||||
gcCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestScanRightDeleteRandom(t *testing.T) {
|
||||
|
||||
|
||||
@ -4,6 +4,7 @@ import (
|
||||
"fmt"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
@ -20,7 +21,8 @@ import (
|
||||
|
||||
var node *nm.Node
|
||||
var chainID = "tendermint_test" // TODO use from config.
|
||||
// var waitForEventTimeout = 5 * time.Second
|
||||
//nolint:unused
|
||||
var waitForEventTimeout = 5 * time.Second
|
||||
|
||||
// TODO fix tests!!
|
||||
|
||||
@ -41,83 +43,84 @@ func kvstoreTx(k, v []byte) []byte {
|
||||
|
||||
// TODO: enable it after general proof format has been adapted
|
||||
// in abci/examples/kvstore.go
|
||||
// func TestAppProofs(t *testing.T) {
|
||||
// assert, require := assert.New(t), require.New(t)
|
||||
//nolint:unused,deadcode
|
||||
func _TestAppProofs(t *testing.T) {
|
||||
assert, require := assert.New(t), require.New(t)
|
||||
|
||||
// prt := defaultProofRuntime()
|
||||
// cl := client.NewLocal(node)
|
||||
// client.WaitForHeight(cl, 1, nil)
|
||||
prt := defaultProofRuntime()
|
||||
cl := client.NewLocal(node)
|
||||
client.WaitForHeight(cl, 1, nil)
|
||||
|
||||
// // This sets up our trust on the node based on some past point.
|
||||
// source := certclient.NewProvider(chainID, cl)
|
||||
// seed, err := source.LatestFullCommit(chainID, 1, 1)
|
||||
// require.NoError(err, "%#v", err)
|
||||
// cert := lite.NewBaseVerifier(chainID, seed.Height(), seed.Validators)
|
||||
// This sets up our trust on the node based on some past point.
|
||||
source := certclient.NewProvider(chainID, cl)
|
||||
seed, err := source.LatestFullCommit(chainID, 1, 1)
|
||||
require.NoError(err, "%#v", err)
|
||||
cert := lite.NewBaseVerifier(chainID, seed.Height(), seed.Validators)
|
||||
|
||||
// // Wait for tx confirmation.
|
||||
// done := make(chan int64)
|
||||
// go func() {
|
||||
// evtTyp := types.EventTx
|
||||
// _, err = client.WaitForOneEvent(cl, evtTyp, waitForEventTimeout)
|
||||
// require.Nil(err, "%#v", err)
|
||||
// close(done)
|
||||
// }()
|
||||
// Wait for tx confirmation.
|
||||
done := make(chan int64)
|
||||
go func() {
|
||||
evtTyp := types.EventTx
|
||||
_, err = client.WaitForOneEvent(cl, evtTyp, waitForEventTimeout)
|
||||
require.Nil(err, "%#v", err)
|
||||
close(done)
|
||||
}()
|
||||
|
||||
// // Submit a transaction.
|
||||
// k := []byte("my-key")
|
||||
// v := []byte("my-value")
|
||||
// tx := kvstoreTx(k, v)
|
||||
// br, err := cl.BroadcastTxCommit(tx)
|
||||
// require.NoError(err, "%#v", err)
|
||||
// require.EqualValues(0, br.CheckTx.Code, "%#v", br.CheckTx)
|
||||
// require.EqualValues(0, br.DeliverTx.Code)
|
||||
// brh := br.Height
|
||||
// Submit a transaction.
|
||||
k := []byte("my-key")
|
||||
v := []byte("my-value")
|
||||
tx := kvstoreTx(k, v)
|
||||
br, err := cl.BroadcastTxCommit(tx)
|
||||
require.NoError(err, "%#v", err)
|
||||
require.EqualValues(0, br.CheckTx.Code, "%#v", br.CheckTx)
|
||||
require.EqualValues(0, br.DeliverTx.Code)
|
||||
brh := br.Height
|
||||
|
||||
// // Fetch latest after tx commit.
|
||||
// <-done
|
||||
// latest, err := source.LatestFullCommit(chainID, 1, 1<<63-1)
|
||||
// require.NoError(err, "%#v", err)
|
||||
// rootHash := latest.SignedHeader.AppHash
|
||||
// if rootHash == nil {
|
||||
// // Fetch one block later, AppHash hasn't been committed yet.
|
||||
// // TODO find a way to avoid doing this.
|
||||
// client.WaitForHeight(cl, latest.SignedHeader.Height+1, nil)
|
||||
// latest, err = source.LatestFullCommit(chainID, latest.SignedHeader.Height+1, 1<<63-1)
|
||||
// require.NoError(err, "%#v", err)
|
||||
// rootHash = latest.SignedHeader.AppHash
|
||||
// }
|
||||
// require.NotNil(rootHash)
|
||||
// Fetch latest after tx commit.
|
||||
<-done
|
||||
latest, err := source.LatestFullCommit(chainID, 1, 1<<63-1)
|
||||
require.NoError(err, "%#v", err)
|
||||
rootHash := latest.SignedHeader.AppHash
|
||||
if rootHash == nil {
|
||||
// Fetch one block later, AppHash hasn't been committed yet.
|
||||
// TODO find a way to avoid doing this.
|
||||
client.WaitForHeight(cl, latest.SignedHeader.Height+1, nil)
|
||||
latest, err = source.LatestFullCommit(chainID, latest.SignedHeader.Height+1, 1<<63-1)
|
||||
require.NoError(err, "%#v", err)
|
||||
rootHash = latest.SignedHeader.AppHash
|
||||
}
|
||||
require.NotNil(rootHash)
|
||||
|
||||
// // verify a query before the tx block has no data (and valid non-exist proof)
|
||||
// bs, height, proof, err := GetWithProof(prt, k, brh-1, cl, cert)
|
||||
// require.NoError(err, "%#v", err)
|
||||
// // require.NotNil(proof)
|
||||
// // TODO: Ensure that *some* keys will be there, ensuring that proof is nil,
|
||||
// // (currently there's a race condition)
|
||||
// // and ensure that proof proves absence of k.
|
||||
// require.Nil(bs)
|
||||
|
||||
// // but given that block it is good
|
||||
// bs, height, proof, err = GetWithProof(prt, k, brh, cl, cert)
|
||||
// require.NoError(err, "%#v", err)
|
||||
// verify a query before the tx block has no data (and valid non-exist proof)
|
||||
bs, height, proof, err := GetWithProof(prt, k, brh-1, cl, cert)
|
||||
require.NoError(err, "%#v", err)
|
||||
// require.NotNil(proof)
|
||||
// require.Equal(height, brh)
|
||||
// TODO: Ensure that *some* keys will be there, ensuring that proof is nil,
|
||||
// (currently there's a race condition)
|
||||
// and ensure that proof proves absence of k.
|
||||
require.Nil(bs)
|
||||
|
||||
// assert.EqualValues(v, bs)
|
||||
// err = prt.VerifyValue(proof, rootHash, string(k), bs) // XXX key encoding
|
||||
// assert.NoError(err, "%#v", err)
|
||||
// but given that block it is good
|
||||
bs, height, proof, err = GetWithProof(prt, k, brh, cl, cert)
|
||||
require.NoError(err, "%#v", err)
|
||||
require.NotNil(proof)
|
||||
require.Equal(height, brh)
|
||||
|
||||
// // Test non-existing key.
|
||||
// missing := []byte("my-missing-key")
|
||||
// bs, _, proof, err = GetWithProof(prt, missing, 0, cl, cert)
|
||||
// require.NoError(err)
|
||||
// require.Nil(bs)
|
||||
// require.NotNil(proof)
|
||||
// err = prt.VerifyAbsence(proof, rootHash, string(missing)) // XXX VerifyAbsence(), keyencoding
|
||||
// assert.NoError(err, "%#v", err)
|
||||
// err = prt.VerifyAbsence(proof, rootHash, string(k)) // XXX VerifyAbsence(), keyencoding
|
||||
// assert.Error(err, "%#v", err)
|
||||
// }
|
||||
assert.EqualValues(v, bs)
|
||||
err = prt.VerifyValue(proof, rootHash, string(k), bs) // XXX key encoding
|
||||
assert.NoError(err, "%#v", err)
|
||||
|
||||
// Test non-existing key.
|
||||
missing := []byte("my-missing-key")
|
||||
bs, _, proof, err = GetWithProof(prt, missing, 0, cl, cert)
|
||||
require.NoError(err)
|
||||
require.Nil(bs)
|
||||
require.NotNil(proof)
|
||||
err = prt.VerifyAbsence(proof, rootHash, string(missing)) // XXX VerifyAbsence(), keyencoding
|
||||
assert.NoError(err, "%#v", err)
|
||||
err = prt.VerifyAbsence(proof, rootHash, string(k)) // XXX VerifyAbsence(), keyencoding
|
||||
assert.Error(err, "%#v", err)
|
||||
}
|
||||
|
||||
func TestTxProofs(t *testing.T) {
|
||||
assert, require := assert.New(t), require.New(t)
|
||||
|
||||
@ -65,44 +65,45 @@ func TestTrustMetricCopyNilPointer(t *testing.T) {
|
||||
}
|
||||
|
||||
// XXX: This test fails non-deterministically
|
||||
// func _TestTrustMetricStopPause(t *testing.T) {
|
||||
// // The TestTicker will provide manual control over
|
||||
// // the passing of time within the metric
|
||||
// tt := NewTestTicker()
|
||||
// tm := NewMetric()
|
||||
// tm.SetTicker(tt)
|
||||
// tm.Start()
|
||||
// // Allow some time intervals to pass and pause
|
||||
// tt.NextTick()
|
||||
// tt.NextTick()
|
||||
// tm.Pause()
|
||||
//nolint:unused,deadcode
|
||||
func _TestTrustMetricStopPause(t *testing.T) {
|
||||
// The TestTicker will provide manual control over
|
||||
// the passing of time within the metric
|
||||
tt := NewTestTicker()
|
||||
tm := NewMetric()
|
||||
tm.SetTicker(tt)
|
||||
tm.Start()
|
||||
// Allow some time intervals to pass and pause
|
||||
tt.NextTick()
|
||||
tt.NextTick()
|
||||
tm.Pause()
|
||||
|
||||
// // could be 1 or 2 because Pause and NextTick race
|
||||
// first := tm.Copy().numIntervals
|
||||
// could be 1 or 2 because Pause and NextTick race
|
||||
first := tm.Copy().numIntervals
|
||||
|
||||
// // Allow more time to pass and check the intervals are unchanged
|
||||
// tt.NextTick()
|
||||
// tt.NextTick()
|
||||
// assert.Equal(t, first, tm.Copy().numIntervals)
|
||||
// Allow more time to pass and check the intervals are unchanged
|
||||
tt.NextTick()
|
||||
tt.NextTick()
|
||||
assert.Equal(t, first, tm.Copy().numIntervals)
|
||||
|
||||
// // Get the trust metric activated again
|
||||
// tm.GoodEvents(5)
|
||||
// // Allow some time intervals to pass and stop
|
||||
// tt.NextTick()
|
||||
// tt.NextTick()
|
||||
// tm.Stop()
|
||||
// tm.Wait()
|
||||
// Get the trust metric activated again
|
||||
tm.GoodEvents(5)
|
||||
// Allow some time intervals to pass and stop
|
||||
tt.NextTick()
|
||||
tt.NextTick()
|
||||
tm.Stop()
|
||||
tm.Wait()
|
||||
|
||||
// second := tm.Copy().numIntervals
|
||||
// // Allow more intervals to pass while the metric is stopped
|
||||
// // and check that the number of intervals match
|
||||
// tm.NextTimeInterval()
|
||||
// tm.NextTimeInterval()
|
||||
// // XXX: fails non-deterministically:
|
||||
// // expected 5, got 6
|
||||
// assert.Equal(t, second+2, tm.Copy().numIntervals)
|
||||
second := tm.Copy().numIntervals
|
||||
// Allow more intervals to pass while the metric is stopped
|
||||
// and check that the number of intervals match
|
||||
tm.NextTimeInterval()
|
||||
tm.NextTimeInterval()
|
||||
// XXX: fails non-deterministically:
|
||||
// expected 5, got 6
|
||||
assert.Equal(t, second+2, tm.Copy().numIntervals)
|
||||
|
||||
// if first > second {
|
||||
// t.Fatalf("numIntervals should always increase or stay the same over time")
|
||||
// }
|
||||
// }
|
||||
if first > second {
|
||||
t.Fatalf("numIntervals should always increase or stay the same over time")
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user