func simpleConsensusState(nValidators int) (*ConsensusState, []*validatorStub) {
// Get State
state, privVals := randGenesisState(nValidators, false, 10)
// fmt.Println(state.Validators)
vss := make([]*validatorStub, nValidators)
// make consensus state for lead validator
// Get BlockStore
blockDB := dbm.NewMemDB()
blockStore := bc.NewBlockStore(blockDB)
// one for mempool, one for consensus
app := example.NewCounterApplication(false)
appCMem := app.Open()
appCCon := app.Open()
proxyAppCtxMem := proxy.NewLocalAppContext(appCMem)
proxyAppCtxCon := proxy.NewLocalAppContext(appCCon)
// Make Mempool
mempool := mempl.NewMempool(proxyAppCtxMem)
// Make ConsensusReactor
cs := NewConsensusState(state, proxyAppCtxCon, blockStore, mempool)
cs.SetPrivValidator(privVals[0])
evsw := events.NewEventSwitch()
cs.SetEventSwitch(evsw)
evsw.Start()
// start the transition routines
// cs.startRoutines()
for i := 0; i < nValidators; i++ {
vss[i] = NewValidatorStub(privVals[i])
}
// since cs1 starts at 1
incrementHeight(vss[1:]...)
return cs, vss
}
func TestSerialReap(t *testing.T) {
app := example.NewCounterApplication(true)
appCtxMempool := app.Open()
proxyAppCtx := proxy.NewLocalAppContext(appCtxMempool)
mempool := NewMempool(proxyAppCtx)
// Create another AppContext for committing.
appCtxConsensus := app.Open()
appCtxConsensus.SetOption("serial", "on")
appendTxsRange := func(start, end int) {
// Append some txs.
for i := start; i < end; i++ {
// This will succeed
txBytes := make([]byte, 32)
binary.LittleEndian.PutUint64(txBytes, uint64(i))
err := mempool.AppendTx(txBytes)
if err != nil {
t.Fatal("Error after AppendTx: %v", err)
}
// This will fail because not serial (incrementing)
// However, error should still be nil.
// It just won't show up on Reap().
err = mempool.AppendTx(txBytes)
if err != nil {
t.Fatal("Error after AppendTx: %v", err)
}
}
}
reapCheck := func(exp int) {
txs, _, err := mempool.Reap()
if err != nil {
t.Error("Error in mempool.Reap()", err)
}
if len(txs) != exp {
t.Fatalf("Expected to reap %v txs but got %v", exp, len(txs))
}
}
updateRange := func(start, end int) {
txs := make([]types.Tx, 0)
for i := start; i < end; i++ {
txBytes := make([]byte, 32)
binary.LittleEndian.PutUint64(txBytes, uint64(i))
txs = append(txs, txBytes)
}
blockHeader := &types.Header{Height: 0}
blockData := &types.Data{Txs: txs}
block := &types.Block{Header: blockHeader, Data: blockData}
err := mempool.Update(block)
if err != nil {
t.Error("Error in mempool.Update()", err)
}
}
commitRange := func(start, end int) {
// Append some txs.
for i := start; i < end; i++ {
txBytes := make([]byte, 32)
binary.LittleEndian.PutUint64(txBytes, uint64(i))
_, retCode := appCtxConsensus.AppendTx(txBytes)
if retCode != tmsp.RetCodeOK {
t.Error("Error committing tx", retCode)
}
}
retCode := appCtxConsensus.Commit()
if retCode != tmsp.RetCodeOK {
t.Error("Error committing range", retCode)
}
}
//----------------------------------------
// Append some txs.
appendTxsRange(0, 100)
// Reap the txs.
reapCheck(100)
// Reap again. We should get the same amount
reapCheck(100)
// Append 0 to 999, we should reap 900 txs
// because 100 were already counted.
appendTxsRange(0, 1000)
// Reap the txs.
reapCheck(1000)
// Reap again. We should get the same amount
reapCheck(1000)
// Commit from the conensus AppContext
commitRange(0, 500)
updateRange(0, 500)
// We should have 500 left.
reapCheck(500)
}