tendermint/internal/blockchain/v2/scheduler_test.go

package v2

import (
	"fmt"
	"math"
	"sort"
	"testing"
	"time"

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

	"github.com/tendermint/tendermint/internal/p2p"
	"github.com/tendermint/tendermint/state"
	"github.com/tendermint/tendermint/types"
)

type scTestParams struct {
	peers         map[string]*scPeer
	initHeight    int64
	height        int64
	allB          []int64
	pending       map[int64]p2p.NodeID
	pendingTime   map[int64]time.Time
	received      map[int64]p2p.NodeID
	peerTimeout   time.Duration
	minRecvRate   int64
	targetPending int
	startTime     time.Time
	syncTimeout   time.Duration
}

func verifyScheduler(sc *scheduler) {
	missing := 0
	if sc.maxHeight() >= sc.height {
		missing = int(math.Min(float64(sc.targetPending), float64(sc.maxHeight()-sc.height+1)))
	}
	if len(sc.blockStates) != missing {
		panic(fmt.Sprintf("scheduler block length %d different than target %d", len(sc.blockStates), missing))
	}
}

func newTestScheduler(params scTestParams) *scheduler {
	peers := make(map[p2p.NodeID]*scPeer)
	var maxHeight int64

	initHeight := params.initHeight
	if initHeight == 0 {
		initHeight = 1
	}
	sc := newScheduler(initHeight, params.startTime)
	if params.height != 0 {
		sc.height = params.height
	}

	for id, peer := range params.peers {
		peer.peerID = p2p.NodeID(id)
		peers[p2p.NodeID(id)] = peer
		if maxHeight < peer.height {
			maxHeight = peer.height
		}
	}
	for _, h := range params.allB {
		sc.blockStates[h] = blockStateNew
	}
	for h, pid := range params.pending {
		sc.blockStates[h] = blockStatePending
		sc.pendingBlocks[h] = pid
	}
	for h, tm := range params.pendingTime {
		sc.pendingTime[h] = tm
	}
	for h, pid := range params.received {
		sc.blockStates[h] = blockStateReceived
		sc.receivedBlocks[h] = pid
	}

	sc.peers = peers
	sc.peerTimeout = params.peerTimeout
	if params.syncTimeout == 0 {
		sc.syncTimeout = 10 * time.Second
	} else {
		sc.syncTimeout = params.syncTimeout
	}

	if params.targetPending == 0 {
		sc.targetPending = 10
	} else {
		sc.targetPending = params.targetPending
	}

	sc.minRecvRate = params.minRecvRate

	verifyScheduler(sc)

	return sc
}

func TestScInit(t *testing.T) {
	var (
		initHeight int64 = 5
		sc               = newScheduler(initHeight, time.Now())
	)
	assert.Equal(t, blockStateProcessed, sc.getStateAtHeight(initHeight-1))
	assert.Equal(t, blockStateUnknown, sc.getStateAtHeight(initHeight))
	assert.Equal(t, blockStateUnknown, sc.getStateAtHeight(initHeight+1))
}

func TestScMaxHeights(t *testing.T) {

	tests := []struct {
		name    string
		sc      scheduler
		wantMax int64
	}{
		{
			name:    "no peers",
			sc:      scheduler{height: 11},
			wantMax: 10,
		},
		{
			name: "one ready peer",
			sc: scheduler{
				height: 3,
				peers:  map[p2p.NodeID]*scPeer{"P1": {height: 6, state: peerStateReady}},
			},
			wantMax: 6,
		},
		{
			name: "ready and removed peers",
			sc: scheduler{
				height: 1,
				peers: map[p2p.NodeID]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 10, state: peerStateRemoved}},
			},
			wantMax: 4,
		},
		{
			name: "removed peers",
			sc: scheduler{
				height: 1,
				peers: map[p2p.NodeID]*scPeer{
					"P1": {height: 4, state: peerStateRemoved},
					"P2": {height: 10, state: peerStateRemoved}},
			},
			wantMax: 0,
		},
		{
			name: "new peers",
			sc: scheduler{
				height: 1,
				peers: map[p2p.NodeID]*scPeer{
					"P1": {base: -1, height: -1, state: peerStateNew},
					"P2": {base: -1, height: -1, state: peerStateNew}},
			},
			wantMax: 0,
		},
		{
			name: "mixed peers",
			sc: scheduler{
				height: 1,
				peers: map[p2p.NodeID]*scPeer{
					"P1": {height: -1, state: peerStateNew},
					"P2": {height: 10, state: peerStateReady},
					"P3": {height: 20, state: peerStateRemoved},
					"P4": {height: 22, state: peerStateReady},
				},
			},
			wantMax: 22,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			// maxHeight() should not mutate the scheduler
			wantSc := tt.sc

			resMax := tt.sc.maxHeight()
			assert.Equal(t, tt.wantMax, resMax)
			assert.Equal(t, wantSc, tt.sc)
		})
	}
}

func TestScEnsurePeer(t *testing.T) {

	type args struct {
		peerID p2p.NodeID
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
	}{
		{
			name:       "add first peer",
			fields:     scTestParams{},
			args:       args{peerID: "P1"},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {base: -1, height: -1, state: peerStateNew}}},
		},
		{
			name:   "add second peer",
			fields: scTestParams{peers: map[string]*scPeer{"P1": {base: -1, height: -1, state: peerStateNew}}},
			args:   args{peerID: "P2"},
			wantFields: scTestParams{peers: map[string]*scPeer{
				"P1": {base: -1, height: -1, state: peerStateNew},
				"P2": {base: -1, height: -1, state: peerStateNew}}},
		},
		{
			name:       "add duplicate peer is fine",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
			args:       args{peerID: "P1"},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
		},
		{
			name: "add duplicate peer with existing peer in Ready state is noop",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 3}},
				allB:  []int64{1, 2, 3},
			},
			args: args{peerID: "P1"},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 3}},
				allB:  []int64{1, 2, 3},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			sc.ensurePeer(tt.args.peerID)
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
		})
	}
}

func TestScTouchPeer(t *testing.T) {
	now := time.Now()

	type args struct {
		peerID p2p.NodeID
		time   time.Time
	}

	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name: "attempt to touch non existing peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 5}},
				allB:  []int64{1, 2, 3, 4, 5},
			},
			args: args{peerID: "P2", time: now},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 5}},
				allB: []int64{1, 2, 3, 4, 5},
			},
			wantErr: true,
		},
		{
			name:       "attempt to touch peer in state New",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {}}},
			args:       args{peerID: "P1", time: now},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {}}},
			wantErr:    true,
		},
		{
			name:       "attempt to touch peer in state Removed",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateRemoved}, "P2": {state: peerStateReady}}},
			args:       args{peerID: "P1", time: now},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateRemoved}, "P2": {state: peerStateReady}}},
			wantErr:    true,
		},
		{
			name:   "touch peer in state Ready",
			fields: scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateReady, lastTouched: now}}},
			args:   args{peerID: "P1", time: now.Add(3 * time.Second)},
			wantFields: scTestParams{peers: map[string]*scPeer{
				"P1": {state: peerStateReady, lastTouched: now.Add(3 * time.Second)}}},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			if err := sc.touchPeer(tt.args.peerID, tt.args.time); (err != nil) != tt.wantErr {
				t.Errorf("touchPeer() wantErr %v, error = %v", tt.wantErr, err)
			}
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
		})
	}
}

func TestScPrunablePeers(t *testing.T) {
	now := time.Now()

	type args struct {
		threshold time.Duration
		time      time.Time
		minSpeed  int64
	}

	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantResult []p2p.NodeID
	}{
		{
			name:       "no peers",
			fields:     scTestParams{peers: map[string]*scPeer{}},
			args:       args{threshold: time.Second, time: now.Add(time.Second + time.Millisecond), minSpeed: 100},
			wantResult: []p2p.NodeID{},
		},
		{
			name: "mixed peers",
			fields: scTestParams{peers: map[string]*scPeer{
				// X - removed, active, fast
				"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101},
				// X - ready, active, fast
				"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101},
				// X - removed, active, equal
				"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100},
				// V - ready, inactive, equal
				"P4": {state: peerStateReady, lastTouched: now, lastRate: 100},
				// V - ready, inactive, slow
				"P5": {state: peerStateReady, lastTouched: now, lastRate: 99},
				//  V - ready, active, slow
				"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90},
			}},
			args:       args{threshold: time.Second, time: now.Add(time.Second + time.Millisecond), minSpeed: 100},
			wantResult: []p2p.NodeID{"P4", "P5", "P6"},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			// peersSlowerThan should not mutate the scheduler
			wantSc := sc
			res := sc.prunablePeers(tt.args.threshold, tt.args.minSpeed, tt.args.time)
			assert.Equal(t, tt.wantResult, res)
			assert.Equal(t, wantSc, sc)
		})
	}
}

func TestScRemovePeer(t *testing.T) {

	type args struct {
		peerID p2p.NodeID
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name:       "remove non existing peer",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
			args:       args{peerID: "P2"},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
		},
		{
			name:       "remove single New peer",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
			args:       args{peerID: "P1"},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateRemoved}}},
		},
		{
			name:       "remove one of two New peers",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}, "P2": {height: -1}}},
			args:       args{peerID: "P1"},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateRemoved}, "P2": {height: -1}}},
		},
		{
			name: "remove one Ready peer, all peers removed",
			fields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 10, state: peerStateRemoved},
					"P2": {height: 5, state: peerStateReady}},
				allB: []int64{1, 2, 3, 4, 5},
			},
			args: args{peerID: "P2"},
			wantFields: scTestParams{peers: map[string]*scPeer{
				"P1": {height: 10, state: peerStateRemoved},
				"P2": {height: 5, state: peerStateRemoved}},
			},
		},
		{
			name: "attempt to remove already removed peer",
			fields: scTestParams{
				height: 8,
				peers: map[string]*scPeer{
					"P1": {height: 10, state: peerStateRemoved},
					"P2": {height: 11, state: peerStateReady}},
				allB: []int64{8, 9, 10, 11},
			},
			args: args{peerID: "P1"},
			wantFields: scTestParams{
				height: 8,
				peers: map[string]*scPeer{
					"P1": {height: 10, state: peerStateRemoved},
					"P2": {height: 11, state: peerStateReady}},
				allB: []int64{8, 9, 10, 11}},
		},
		{
			name: "remove Ready peer with blocks requested",
			fields: scTestParams{
				peers:   map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
				allB:    []int64{1, 2, 3},
				pending: map[int64]p2p.NodeID{1: "P1"},
			},
			args: args{peerID: "P1"},
			wantFields: scTestParams{
				peers:   map[string]*scPeer{"P1": {height: 3, state: peerStateRemoved}},
				allB:    []int64{},
				pending: map[int64]p2p.NodeID{},
			},
		},
		{
			name: "remove Ready peer with blocks received",
			fields: scTestParams{
				peers:    map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
				allB:     []int64{1, 2, 3},
				received: map[int64]p2p.NodeID{1: "P1"},
			},
			args: args{peerID: "P1"},
			wantFields: scTestParams{
				peers:    map[string]*scPeer{"P1": {height: 3, state: peerStateRemoved}},
				allB:     []int64{},
				received: map[int64]p2p.NodeID{},
			},
		},
		{
			name: "remove Ready peer with blocks received and requested (not yet received)",
			fields: scTestParams{
				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:     []int64{1, 2, 3, 4},
				pending:  map[int64]p2p.NodeID{1: "P1", 3: "P1"},
				received: map[int64]p2p.NodeID{2: "P1", 4: "P1"},
			},
			args: args{peerID: "P1"},
			wantFields: scTestParams{
				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}},
				allB:     []int64{},
				pending:  map[int64]p2p.NodeID{},
				received: map[int64]p2p.NodeID{},
			},
		},
		{
			name: "remove Ready peer from multiple peers set, with blocks received and requested (not yet received)",
			fields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 6, state: peerStateReady},
					"P2": {height: 6, state: peerStateReady},
				},
				allB:     []int64{1, 2, 3, 4, 5, 6},
				pending:  map[int64]p2p.NodeID{1: "P1", 3: "P2", 6: "P1"},
				received: map[int64]p2p.NodeID{2: "P1", 4: "P2", 5: "P2"},
			},
			args: args{peerID: "P1"},
			wantFields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 6, state: peerStateRemoved},
					"P2": {height: 6, state: peerStateReady},
				},
				allB:     []int64{1, 2, 3, 4, 5, 6},
				pending:  map[int64]p2p.NodeID{3: "P2"},
				received: map[int64]p2p.NodeID{4: "P2", 5: "P2"},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			sc.removePeer(tt.args.peerID)
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
		})
	}
}

func TestScSetPeerRange(t *testing.T) {

	type args struct {
		peerID p2p.NodeID
		base   int64
		height int64
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name: "change height of non existing peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			args: args{peerID: "P2", height: 4},
			wantFields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 2, state: peerStateReady},
					"P2": {height: 4, state: peerStateReady},
				},
				allB: []int64{1, 2, 3, 4}},
		},
		{
			name: "increase height of removed peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
			args:       args{peerID: "P1", height: 4},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
		},
		{
			name: "decrease height of single peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4}},
			args: args{peerID: "P1", height: 2},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}},
				allB:  []int64{}},
			wantErr: true,
		},
		{
			name: "increase height of single peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			args: args{peerID: "P1", height: 4},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4}},
		},
		{
			name: "noop height change of single peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4}},
			args: args{peerID: "P1", height: 4},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4}},
		},
		{
			name: "add peer with huge height 10**10 ",
			fields: scTestParams{
				peers:         map[string]*scPeer{"P2": {height: -1, state: peerStateNew}},
				targetPending: 4,
			},
			args: args{peerID: "P2", height: 10000000000},
			wantFields: scTestParams{
				targetPending: 4,
				peers:         map[string]*scPeer{"P2": {height: 10000000000, state: peerStateReady}},
				allB:          []int64{1, 2, 3, 4}},
		},
		{
			name: "add peer with base > height should error",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4}},
			args: args{peerID: "P1", base: 6, height: 5},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
			wantErr: true,
		},
		{
			name: "add peer with base == height is fine",
			fields: scTestParams{
				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateNew}},
				targetPending: 4,
			},
			args: args{peerID: "P1", base: 6, height: 6},
			wantFields: scTestParams{
				targetPending: 4,
				peers:         map[string]*scPeer{"P1": {base: 6, height: 6, state: peerStateReady}},
				allB:          []int64{1, 2, 3, 4}},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			err := sc.setPeerRange(tt.args.peerID, tt.args.base, tt.args.height)
			if (err != nil) != tt.wantErr {
				t.Errorf("setPeerHeight() wantErr %v, error = %v", tt.wantErr, err)
			}
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
		})
	}
}

func TestScGetPeersWithHeight(t *testing.T) {

	type args struct {
		height int64
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantResult []p2p.NodeID
	}{
		{
			name:       "no peers",
			fields:     scTestParams{peers: map[string]*scPeer{}},
			args:       args{height: 10},
			wantResult: []p2p.NodeID{},
		},
		{
			name:       "only new peers",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
			args:       args{height: 10},
			wantResult: []p2p.NodeID{},
		},
		{
			name:       "only Removed peers",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
			args:       args{height: 2},
			wantResult: []p2p.NodeID{},
		},
		{
			name: "one Ready shorter peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4},
			},
			args:       args{height: 5},
			wantResult: []p2p.NodeID{},
		},
		{
			name: "one Ready equal peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4},
			},
			args:       args{height: 4},
			wantResult: []p2p.NodeID{"P1"},
		},
		{
			name: "one Ready higher peer",
			fields: scTestParams{
				targetPending: 4,
				peers:         map[string]*scPeer{"P1": {height: 20, state: peerStateReady}},
				allB:          []int64{1, 2, 3, 4},
			},
			args:       args{height: 4},
			wantResult: []p2p.NodeID{"P1"},
		},
		{
			name: "one Ready higher peer at base",
			fields: scTestParams{
				targetPending: 4,
				peers:         map[string]*scPeer{"P1": {base: 4, height: 20, state: peerStateReady}},
				allB:          []int64{1, 2, 3, 4},
			},
			args:       args{height: 4},
			wantResult: []p2p.NodeID{"P1"},
		},
		{
			name: "one Ready higher peer with higher base",
			fields: scTestParams{
				targetPending: 4,
				peers:         map[string]*scPeer{"P1": {base: 10, height: 20, state: peerStateReady}},
				allB:          []int64{1, 2, 3, 4},
			},
			args:       args{height: 4},
			wantResult: []p2p.NodeID{},
		},
		{
			name: "multiple mixed peers",
			fields: scTestParams{
				height: 8,
				peers: map[string]*scPeer{
					"P1": {height: -1, state: peerStateNew},
					"P2": {height: 10, state: peerStateReady},
					"P3": {height: 5, state: peerStateReady},
					"P4": {height: 20, state: peerStateRemoved},
					"P5": {height: 11, state: peerStateReady}},
				allB: []int64{8, 9, 10, 11},
			},
			args:       args{height: 8},
			wantResult: []p2p.NodeID{"P2", "P5"},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			// getPeersWithHeight should not mutate the scheduler
			wantSc := sc
			res := sc.getPeersWithHeight(tt.args.height)
			sort.Sort(PeerByID(res))
			assert.Equal(t, tt.wantResult, res)
			assert.Equal(t, wantSc, sc)
		})
	}
}

func TestScMarkPending(t *testing.T) {
	now := time.Now()

	type args struct {
		peerID p2p.NodeID
		height int64
		tm     time.Time
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name: "attempt mark pending an unknown block above height",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			args: args{peerID: "P1", height: 3, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			wantErr: true,
		},
		{
			name: "attempt mark pending an unknown block below base",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {base: 4, height: 6, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4, 5, 6}},
			args: args{peerID: "P1", height: 3, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {base: 4, height: 6, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4, 5, 6}},
			wantErr: true,
		},
		{
			name: "attempt mark pending from non existing peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			args: args{peerID: "P2", height: 1, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			wantErr: true,
		},
		{
			name: "mark pending from Removed peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
			args: args{peerID: "P1", height: 1, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
			wantErr: true,
		},
		{
			name: "mark pending from New peer",
			fields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 4, state: peerStateNew},
				},
				allB: []int64{1, 2, 3, 4},
			},
			args: args{peerID: "P2", height: 2, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 4, state: peerStateNew},
				},
				allB: []int64{1, 2, 3, 4},
			},
			wantErr: true,
		},
		{
			name: "mark pending from short peer",
			fields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 2, state: peerStateReady},
				},
				allB: []int64{1, 2, 3, 4},
			},
			args: args{peerID: "P2", height: 3, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 2, state: peerStateReady},
				},
				allB: []int64{1, 2, 3, 4},
			},
			wantErr: true,
		},
		{
			name: "mark pending all good",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{1: "P1"},
				pendingTime: map[int64]time.Time{1: now},
			},
			args: args{peerID: "P1", height: 2, tm: now.Add(time.Millisecond)},
			wantFields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Millisecond)},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			if err := sc.markPending(tt.args.peerID, tt.args.height, tt.args.tm); (err != nil) != tt.wantErr {
				t.Errorf("markPending() wantErr %v, error = %v", tt.wantErr, err)
			}
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc)
		})
	}
}

func TestScMarkReceived(t *testing.T) {
	now := time.Now()

	type args struct {
		peerID p2p.NodeID
		height int64
		size   int64
		tm     time.Time
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name: "received from non existing peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			args: args{peerID: "P2", height: 1, size: 1000, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			wantErr: true,
		},
		{
			name: "received from removed peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
			args: args{peerID: "P1", height: 1, size: 1000, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
			wantErr: true,
		},
		{
			name: "received from unsolicited peer",
			fields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 4, state: peerStateReady},
				},
				allB:    []int64{1, 2, 3, 4},
				pending: map[int64]p2p.NodeID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
			},
			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
			wantFields: scTestParams{
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 4, state: peerStateReady},
				},
				allB:    []int64{1, 2, 3, 4},
				pending: map[int64]p2p.NodeID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
			},
			wantErr: true,
		},
		{
			name: "received but blockRequest not sent",
			fields: scTestParams{
				peers:   map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:    []int64{1, 2, 3, 4},
				pending: map[int64]p2p.NodeID{},
			},
			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
			wantFields: scTestParams{
				peers:   map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:    []int64{1, 2, 3, 4},
				pending: map[int64]p2p.NodeID{},
			},
			wantErr: true,
		},
		{
			name: "received with bad timestamp",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Second)},
			},
			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
			wantFields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Second)},
			},
			wantErr: true,
		},
		{
			name: "received all good",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
				pendingTime: map[int64]time.Time{1: now, 2: now},
			},
			args: args{peerID: "P1", height: 2, size: 1000, tm: now.Add(time.Millisecond)},
			wantFields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{1: "P1"},
				pendingTime: map[int64]time.Time{1: now},
				received:    map[int64]p2p.NodeID{2: "P1"},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			if err := sc.markReceived(
				tt.args.peerID,
				tt.args.height,
				tt.args.size,
				now.Add(time.Second)); (err != nil) != tt.wantErr {
				t.Errorf("markReceived() wantErr %v, error = %v", tt.wantErr, err)
			}
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc)
		})
	}
}

func TestScMarkProcessed(t *testing.T) {
	now := time.Now()

	type args struct {
		height int64
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name: "processed an unreceived block",
			fields: scTestParams{
				height:        2,
				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:          []int64{2},
				pending:       map[int64]p2p.NodeID{2: "P1"},
				pendingTime:   map[int64]time.Time{2: now},
				targetPending: 1,
			},
			args: args{height: 2},
			wantFields: scTestParams{
				height:        3,
				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:          []int64{3},
				targetPending: 1,
			},
		},
		{
			name: "mark processed success",
			fields: scTestParams{
				height:      1,
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{1, 2},
				pending:     map[int64]p2p.NodeID{2: "P1"},
				pendingTime: map[int64]time.Time{2: now},
				received:    map[int64]p2p.NodeID{1: "P1"}},
			args: args{height: 1},
			wantFields: scTestParams{
				height:      2,
				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:        []int64{2},
				pending:     map[int64]p2p.NodeID{2: "P1"},
				pendingTime: map[int64]time.Time{2: now}},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			oldBlockState := sc.getStateAtHeight(tt.args.height)
			if err := sc.markProcessed(tt.args.height); (err != nil) != tt.wantErr {
				t.Errorf("markProcessed() wantErr %v, error = %v", tt.wantErr, err)
			}
			if tt.wantErr {
				assert.Equal(t, oldBlockState, sc.getStateAtHeight(tt.args.height))
			} else {
				assert.Equal(t, blockStateProcessed, sc.getStateAtHeight(tt.args.height))
			}
			wantSc := newTestScheduler(tt.wantFields)
			checkSameScheduler(t, wantSc, sc)
		})
	}
}

func TestScResetState(t *testing.T) {
	tests := []struct {
		name       string
		fields     scTestParams
		state      state.State
		wantFields scTestParams
	}{
		{
			name: "updates height and initHeight",
			fields: scTestParams{
				height:     0,
				initHeight: 0,
			},
			state: state.State{LastBlockHeight: 7},
			wantFields: scTestParams{
				height:     8,
				initHeight: 8,
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			e, err := sc.handleResetState(bcResetState{state: tt.state})
			require.NoError(t, err)
			assert.Equal(t, e, noOp)
			wantSc := newTestScheduler(tt.wantFields)
			checkSameScheduler(t, wantSc, sc)
		})
	}
}

func TestScAllBlocksProcessed(t *testing.T) {
	now := time.Now()

	tests := []struct {
		name       string
		fields     scTestParams
		wantResult bool
	}{
		{
			name:       "no blocks, no peers",
			fields:     scTestParams{},
			wantResult: false,
		},
		{
			name: "only New blocks",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4},
			},
			wantResult: false,
		},
		{
			name: "only Pending blocks",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4},
				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
				pendingTime: map[int64]time.Time{1: now, 2: now, 3: now, 4: now},
			},
			wantResult: false,
		},
		{
			name: "only Received blocks",
			fields: scTestParams{
				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:     []int64{1, 2, 3, 4},
				received: map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
			},
			wantResult: false,
		},
		{
			name: "only Processed blocks plus highest is received",
			fields: scTestParams{
				height: 4,
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady}},
				allB:     []int64{4},
				received: map[int64]p2p.NodeID{4: "P1"},
			},
			wantResult: true,
		},
		{
			name: "mixed block states",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4},
				pending:     map[int64]p2p.NodeID{2: "P1", 4: "P1"},
				pendingTime: map[int64]time.Time{2: now, 4: now},
			},
			wantResult: false,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			// allBlocksProcessed() should not mutate the scheduler
			wantSc := sc
			res := sc.allBlocksProcessed()
			assert.Equal(t, tt.wantResult, res)
			checkSameScheduler(t, wantSc, sc)
		})
	}
}

func TestScNextHeightToSchedule(t *testing.T) {
	now := time.Now()

	tests := []struct {
		name       string
		fields     scTestParams
		wantHeight int64
	}{
		{
			name:       "no blocks",
			fields:     scTestParams{initHeight: 11, height: 11},
			wantHeight: -1,
		},
		{
			name: "only New blocks",
			fields: scTestParams{
				initHeight: 3,
				peers:      map[string]*scPeer{"P1": {height: 6, state: peerStateReady}},
				allB:       []int64{3, 4, 5, 6},
			},
			wantHeight: 3,
		},
		{
			name: "only Pending blocks",
			fields: scTestParams{
				initHeight:  1,
				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4},
				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
				pendingTime: map[int64]time.Time{1: now, 2: now, 3: now, 4: now},
			},
			wantHeight: -1,
		},
		{
			name: "only Received blocks",
			fields: scTestParams{
				initHeight: 1,
				peers:      map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:       []int64{1, 2, 3, 4},
				received:   map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
			},
			wantHeight: -1,
		},
		{
			name: "only Processed blocks",
			fields: scTestParams{
				initHeight: 1,
				peers:      map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:       []int64{1, 2, 3, 4},
			},
			wantHeight: 1,
		},
		{
			name: "mixed block states",
			fields: scTestParams{
				initHeight:  1,
				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4},
				pending:     map[int64]p2p.NodeID{2: "P1"},
				pendingTime: map[int64]time.Time{2: now},
			},
			wantHeight: 1,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			// nextHeightToSchedule() should not mutate the scheduler
			wantSc := sc

			resMin := sc.nextHeightToSchedule()
			assert.Equal(t, tt.wantHeight, resMin)
			checkSameScheduler(t, wantSc, sc)
		})
	}
}

func TestScSelectPeer(t *testing.T) {

	type args struct {
		height int64
	}
	tests := []struct {
		name       string
		fields     scTestParams
		args       args
		wantResult p2p.NodeID
		wantError  bool
	}{
		{
			name:       "no peers",
			fields:     scTestParams{peers: map[string]*scPeer{}},
			args:       args{height: 10},
			wantResult: "",
			wantError:  true,
		},
		{
			name:       "only new peers",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
			args:       args{height: 10},
			wantResult: "",
			wantError:  true,
		},
		{
			name:       "only Removed peers",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
			args:       args{height: 2},
			wantResult: "",
			wantError:  true,
		},
		{
			name: "one Ready shorter peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4},
			},
			args:       args{height: 5},
			wantResult: "",
			wantError:  true,
		},
		{
			name: "one Ready equal peer",
			fields: scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB: []int64{1, 2, 3, 4},
			},
			args:       args{height: 4},
			wantResult: "P1",
		},
		{
			name: "one Ready higher peer",
			fields: scTestParams{peers: map[string]*scPeer{"P1": {height: 6, state: peerStateReady}},
				allB: []int64{1, 2, 3, 4, 5, 6},
			},
			args:       args{height: 4},
			wantResult: "P1",
		},
		{
			name: "one Ready higher peer with higher base",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {base: 4, height: 6, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4, 5, 6},
			},
			args:       args{height: 3},
			wantResult: "",
			wantError:  true,
		},
		{
			name: "many Ready higher peers with different number of pending requests",
			fields: scTestParams{
				height: 4,
				peers: map[string]*scPeer{
					"P1": {height: 8, state: peerStateReady},
					"P2": {height: 9, state: peerStateReady}},
				allB: []int64{4, 5, 6, 7, 8, 9},
				pending: map[int64]p2p.NodeID{
					4: "P1", 6: "P1",
					5: "P2",
				},
			},
			args:       args{height: 4},
			wantResult: "P2",
		},
		{
			name: "many Ready higher peers with same number of pending requests",
			fields: scTestParams{
				peers: map[string]*scPeer{
					"P2": {height: 20, state: peerStateReady},
					"P1": {height: 15, state: peerStateReady},
					"P3": {height: 15, state: peerStateReady}},
				allB: []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
				pending: map[int64]p2p.NodeID{
					1: "P1", 2: "P1",
					3: "P3", 4: "P3",
					5: "P2", 6: "P2",
				},
			},
			args:       args{height: 7},
			wantResult: "P1",
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			// selectPeer should not mutate the scheduler
			wantSc := sc
			res, err := sc.selectPeer(tt.args.height)
			assert.Equal(t, tt.wantResult, res)
			assert.Equal(t, tt.wantError, err != nil)
			checkSameScheduler(t, wantSc, sc)
		})
	}
}

// makeScBlock makes an empty block.
func makeScBlock(height int64) *types.Block {
	return &types.Block{Header: types.Header{Height: height}}
}

// used in place of assert.Equal(t, want, actual) to avoid failures due to
// scheduler.lastAdvanced timestamp inequalities.
func checkSameScheduler(t *testing.T, want *scheduler, actual *scheduler) {
	assert.Equal(t, want.initHeight, actual.initHeight)
	assert.Equal(t, want.height, actual.height)
	assert.Equal(t, want.peers, actual.peers)
	assert.Equal(t, want.blockStates, actual.blockStates)
	assert.Equal(t, want.pendingBlocks, actual.pendingBlocks)
	assert.Equal(t, want.pendingTime, actual.pendingTime)
	assert.Equal(t, want.blockStates, actual.blockStates)
	assert.Equal(t, want.receivedBlocks, actual.receivedBlocks)
	assert.Equal(t, want.blockStates, actual.blockStates)
}

// checkScResults checks scheduler handler test results
func checkScResults(t *testing.T, wantErr bool, err error, wantEvent Event, event Event) {
	if (err != nil) != wantErr {
		t.Errorf("error = %v, wantErr %v", err, wantErr)
		return
	}
	if !assert.IsType(t, wantEvent, event) {
		t.Log(fmt.Sprintf("Wrong type received, got: %v", event))
	}
	switch wantEvent := wantEvent.(type) {
	case scPeerError:
		assert.Equal(t, wantEvent.peerID, event.(scPeerError).peerID)
		assert.Equal(t, wantEvent.reason != nil, event.(scPeerError).reason != nil)
	case scBlockReceived:
		assert.Equal(t, wantEvent.peerID, event.(scBlockReceived).peerID)
		assert.Equal(t, wantEvent.block, event.(scBlockReceived).block)
	case scSchedulerFail:
		assert.Equal(t, wantEvent.reason != nil, event.(scSchedulerFail).reason != nil)
	}
}

func TestScHandleBlockResponse(t *testing.T) {
	now := time.Now()
	block6FromP1 := bcBlockResponse{
		time:   now.Add(time.Millisecond),
		peerID: p2p.NodeID("P1"),
		size:   100,
		block:  makeScBlock(6),
	}

	type args struct {
		event bcBlockResponse
	}

	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name:      "empty scheduler",
			fields:    scTestParams{},
			args:      args{event: block6FromP1},
			wantEvent: noOpEvent{},
		},
		{
			name:      "block from removed peer",
			fields:    scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
			args:      args{event: block6FromP1},
			wantEvent: noOpEvent{},
		},
		{
			name: "block we haven't asked for",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4, 5, 6, 7, 8}},
			args:      args{event: block6FromP1},
			wantEvent: scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
		},
		{
			name: "block from wrong peer",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P2"},
				pendingTime: map[int64]time.Time{6: now},
			},
			args:      args{event: block6FromP1},
			wantEvent: noOpEvent{},
		},
		{
			name: "block with bad timestamp",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P1"},
				pendingTime: map[int64]time.Time{6: now.Add(time.Second)},
			},
			args:      args{event: block6FromP1},
			wantEvent: scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
		},
		{
			name: "good block, accept",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P1"},
				pendingTime: map[int64]time.Time{6: now},
			},
			args:      args{event: block6FromP1},
			wantEvent: scBlockReceived{peerID: "P1", block: block6FromP1.block},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleBlockResponse(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandleNoBlockResponse(t *testing.T) {
	now := time.Now()
	noBlock6FromP1 := bcNoBlockResponse{
		time:   now.Add(time.Millisecond),
		peerID: p2p.NodeID("P1"),
		height: 6,
	}

	tests := []struct {
		name       string
		fields     scTestParams
		wantEvent  Event
		wantFields scTestParams
		wantErr    bool
	}{
		{
			name:       "empty scheduler",
			fields:     scTestParams{},
			wantEvent:  noOpEvent{},
			wantFields: scTestParams{},
		},
		{
			name:       "noBlock from removed peer",
			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
			wantEvent:  noOpEvent{},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
		},
		{
			name: "for block we haven't asked for",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4, 5, 6, 7, 8}},
			wantEvent:  scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
		},
		{
			name: "noBlock from peer we don't have",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P2"},
				pendingTime: map[int64]time.Time{6: now},
			},
			wantEvent: noOpEvent{},
			wantFields: scTestParams{
				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P2"},
				pendingTime: map[int64]time.Time{6: now},
			},
		},
		{
			name: "noBlock from existing peer",
			fields: scTestParams{
				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P1"},
				pendingTime: map[int64]time.Time{6: now},
			},
			wantEvent:  scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleNoBlockResponse(noBlock6FromP1)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
			wantSc := newTestScheduler(tt.wantFields)
			assert.Equal(t, wantSc, sc)
		})
	}
}

func TestScHandleBlockProcessed(t *testing.T) {
	now := time.Now()
	processed6FromP1 := pcBlockProcessed{
		peerID: p2p.NodeID("P1"),
		height: 6,
	}

	type args struct {
		event pcBlockProcessed
	}

	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name:      "empty scheduler",
			fields:    scTestParams{height: 6},
			args:      args{event: processed6FromP1},
			wantEvent: noOpEvent{},
		},
		{
			name: "processed block we don't have",
			fields: scTestParams{
				initHeight:  6,
				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:        []int64{6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P1"},
				pendingTime: map[int64]time.Time{6: now},
			},
			args:      args{event: processed6FromP1},
			wantEvent: noOpEvent{},
		},
		{
			name: "processed block ok, we processed all blocks",
			fields: scTestParams{
				initHeight: 6,
				peers:      map[string]*scPeer{"P1": {height: 7, state: peerStateReady}},
				allB:       []int64{6, 7},
				received:   map[int64]p2p.NodeID{6: "P1", 7: "P1"},
			},
			args:      args{event: processed6FromP1},
			wantEvent: scFinishedEv{},
		},
		{
			name: "processed block ok, we still have blocks to process",
			fields: scTestParams{
				initHeight: 6,
				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:       []int64{6, 7, 8},
				pending:    map[int64]p2p.NodeID{7: "P1", 8: "P1"},
				received:   map[int64]p2p.NodeID{6: "P1"},
			},
			args:      args{event: processed6FromP1},
			wantEvent: noOpEvent{},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleBlockProcessed(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandleBlockVerificationFailure(t *testing.T) {
	now := time.Now()

	type args struct {
		event pcBlockVerificationFailure
	}

	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name:      "empty scheduler",
			fields:    scTestParams{},
			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
			wantEvent: noOpEvent{},
		},
		{
			name: "failed block we don't have, single peer is still removed",
			fields: scTestParams{
				initHeight:  6,
				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:        []int64{6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P1"},
				pendingTime: map[int64]time.Time{6: now},
			},
			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
			wantEvent: scFinishedEv{},
		},
		{
			name: "failed block we don't have, one of two peers are removed",
			fields: scTestParams{
				initHeight:  6,
				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}, "P2": {height: 8, state: peerStateReady}},
				allB:        []int64{6, 7, 8},
				pending:     map[int64]p2p.NodeID{6: "P1"},
				pendingTime: map[int64]time.Time{6: now},
			},
			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
			wantEvent: noOpEvent{},
		},
		{
			name: "failed block, all blocks are processed after removal",
			fields: scTestParams{
				initHeight: 6,
				peers:      map[string]*scPeer{"P1": {height: 7, state: peerStateReady}},
				allB:       []int64{6, 7},
				received:   map[int64]p2p.NodeID{6: "P1", 7: "P1"},
			},
			args:      args{event: pcBlockVerificationFailure{height: 7, firstPeerID: "P1", secondPeerID: "P1"}},
			wantEvent: scFinishedEv{},
		},
		{
			name: "failed block, we still have blocks to process",
			fields: scTestParams{
				initHeight: 5,
				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}, "P2": {height: 8, state: peerStateReady}},
				allB:       []int64{5, 6, 7, 8},
				pending:    map[int64]p2p.NodeID{7: "P1", 8: "P1"},
				received:   map[int64]p2p.NodeID{5: "P1", 6: "P1"},
			},
			args:      args{event: pcBlockVerificationFailure{height: 5, firstPeerID: "P1", secondPeerID: "P1"}},
			wantEvent: noOpEvent{},
		},
		{
			name: "failed block, H+1 and H+2 delivered by different peers, we still have blocks to process",
			fields: scTestParams{
				initHeight: 5,
				peers: map[string]*scPeer{
					"P1": {height: 8, state: peerStateReady},
					"P2": {height: 8, state: peerStateReady},
					"P3": {height: 8, state: peerStateReady},
				},
				allB:     []int64{5, 6, 7, 8},
				pending:  map[int64]p2p.NodeID{7: "P1", 8: "P1"},
				received: map[int64]p2p.NodeID{5: "P1", 6: "P1"},
			},
			args:      args{event: pcBlockVerificationFailure{height: 5, firstPeerID: "P1", secondPeerID: "P2"}},
			wantEvent: noOpEvent{},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleBlockProcessError(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandleAddNewPeer(t *testing.T) {
	addP1 := bcAddNewPeer{
		peerID: p2p.NodeID("P1"),
	}
	type args struct {
		event bcAddNewPeer
	}

	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name:      "add P1 to empty scheduler",
			fields:    scTestParams{},
			args:      args{event: addP1},
			wantEvent: noOpEvent{},
		},
		{
			name: "add duplicate peer",
			fields: scTestParams{
				initHeight: 6,
				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
				allB:       []int64{6, 7, 8},
			},
			args:      args{event: addP1},
			wantEvent: noOpEvent{},
		},
		{
			name: "add P1 to non empty scheduler",
			fields: scTestParams{
				initHeight: 6,
				peers:      map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
				allB:       []int64{6, 7, 8},
			},
			args:      args{event: addP1},
			wantEvent: noOpEvent{},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleAddNewPeer(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandleTryPrunePeer(t *testing.T) {
	now := time.Now()

	pruneEv := rTryPrunePeer{
		time: now.Add(time.Second + time.Millisecond),
	}
	type args struct {
		event rTryPrunePeer
	}

	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name:      "no peers",
			fields:    scTestParams{},
			args:      args{event: pruneEv},
			wantEvent: noOpEvent{},
		},
		{
			name: "no prunable peers",
			fields: scTestParams{
				minRecvRate: 100,
				peers: map[string]*scPeer{
					// X - removed, active, fast
					"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101},
					// X - ready, active, fast
					"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101},
					// X - removed, active, equal
					"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100}},
				peerTimeout: time.Second,
			},
			args:      args{event: pruneEv},
			wantEvent: noOpEvent{},
		},
		{
			name: "mixed peers",
			fields: scTestParams{
				minRecvRate: 100,
				peers: map[string]*scPeer{
					// X - removed, active, fast
					"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
					// X - ready, active, fast
					"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
					// X - removed, active, equal
					"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100, height: 5},
					// V - ready, inactive, equal
					"P4": {state: peerStateReady, lastTouched: now, lastRate: 100, height: 7},
					// V - ready, inactive, slow
					"P5": {state: peerStateReady, lastTouched: now, lastRate: 99, height: 7},
					//  V - ready, active, slow
					"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90, height: 7},
				},
				allB:        []int64{1, 2, 3, 4, 5, 6, 7},
				peerTimeout: time.Second},
			args:      args{event: pruneEv},
			wantEvent: scPeersPruned{peers: []p2p.NodeID{"P4", "P5", "P6"}},
		},
		{
			name: "mixed peers, finish after pruning",
			fields: scTestParams{
				minRecvRate: 100,
				height:      6,
				peers: map[string]*scPeer{
					// X - removed, active, fast
					"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
					// X - ready, active, fast
					"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
					// X - removed, active, equal
					"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100, height: 5},
					// V - ready, inactive, equal
					"P4": {state: peerStateReady, lastTouched: now, lastRate: 100, height: 7},
					// V - ready, inactive, slow
					"P5": {state: peerStateReady, lastTouched: now, lastRate: 99, height: 7},
					//  V - ready, active, slow
					"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90, height: 7},
				},
				allB:        []int64{6, 7},
				peerTimeout: time.Second},
			args:      args{event: pruneEv},
			wantEvent: scFinishedEv{},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleTryPrunePeer(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandleTrySchedule(t *testing.T) {
	now := time.Now()
	tryEv := rTrySchedule{
		time: now.Add(time.Second + time.Millisecond),
	}

	type args struct {
		event rTrySchedule
	}
	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name:      "no peers",
			fields:    scTestParams{startTime: now, peers: map[string]*scPeer{}},
			args:      args{event: tryEv},
			wantEvent: noOpEvent{},
		},
		{
			name:      "only new peers",
			fields:    scTestParams{startTime: now, peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
			args:      args{event: tryEv},
			wantEvent: noOpEvent{},
		},
		{
			name:      "only Removed peers",
			fields:    scTestParams{startTime: now, peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
			args:      args{event: tryEv},
			wantEvent: noOpEvent{},
		},
		{
			name: "one Ready shorter peer",
			fields: scTestParams{
				startTime: now,
				height:    6,
				peers:     map[string]*scPeer{"P1": {height: 4, state: peerStateReady}}},
			args:      args{event: tryEv},
			wantEvent: noOpEvent{},
		},
		{
			name: "one Ready equal peer",
			fields: scTestParams{
				startTime: now,
				peers:     map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
				allB:      []int64{1, 2, 3, 4}},
			args:      args{event: tryEv},
			wantEvent: scBlockRequest{peerID: "P1", height: 1},
		},
		{
			name: "many Ready higher peers with different number of pending requests",
			fields: scTestParams{
				startTime: now,
				peers: map[string]*scPeer{
					"P1": {height: 4, state: peerStateReady},
					"P2": {height: 5, state: peerStateReady}},
				allB: []int64{1, 2, 3, 4, 5},
				pending: map[int64]p2p.NodeID{
					1: "P1", 2: "P1",
					3: "P2",
				},
			},
			args:      args{event: tryEv},
			wantEvent: scBlockRequest{peerID: "P2", height: 4},
		},

		{
			name: "many Ready higher peers with same number of pending requests",
			fields: scTestParams{
				startTime: now,
				peers: map[string]*scPeer{
					"P2": {height: 8, state: peerStateReady},
					"P1": {height: 8, state: peerStateReady},
					"P3": {height: 8, state: peerStateReady}},
				allB: []int64{1, 2, 3, 4, 5, 6, 7, 8},
				pending: map[int64]p2p.NodeID{
					1: "P1", 2: "P1",
					3: "P3", 4: "P3",
					5: "P2", 6: "P2",
				},
			},
			args:      args{event: tryEv},
			wantEvent: scBlockRequest{peerID: "P1", height: 7},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleTrySchedule(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandleStatusResponse(t *testing.T) {
	now := time.Now()
	statusRespP1Ev := bcStatusResponse{
		time:   now.Add(time.Second + time.Millisecond),
		peerID: "P1",
		height: 6,
	}

	type args struct {
		event bcStatusResponse
	}
	tests := []struct {
		name      string
		fields    scTestParams
		args      args
		wantEvent Event
		wantErr   bool
	}{
		{
			name: "change height of non existing peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P2": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2},
			},
			args:      args{event: statusRespP1Ev},
			wantEvent: noOpEvent{},
		},

		{
			name:      "increase height of removed peer",
			fields:    scTestParams{peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
			args:      args{event: statusRespP1Ev},
			wantEvent: noOpEvent{},
		},

		{
			name: "decrease height of single peer",
			fields: scTestParams{
				height: 5,
				peers:  map[string]*scPeer{"P1": {height: 10, state: peerStateReady}},
				allB:   []int64{5, 6, 7, 8, 9, 10},
			},
			args:      args{event: statusRespP1Ev},
			wantEvent: scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
		},

		{
			name: "increase height of single peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
				allB:  []int64{1, 2}},
			args:      args{event: statusRespP1Ev},
			wantEvent: noOpEvent{},
		},
		{
			name: "noop height change of single peer",
			fields: scTestParams{
				peers: map[string]*scPeer{"P1": {height: 6, state: peerStateReady}},
				allB:  []int64{1, 2, 3, 4, 5, 6}},
			args:      args{event: statusRespP1Ev},
			wantEvent: noOpEvent{},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			sc := newTestScheduler(tt.fields)
			event, err := sc.handleStatusResponse(tt.args.event)
			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
		})
	}
}

func TestScHandle(t *testing.T) {
	now := time.Now()

	type unknownEv struct {
		priorityNormal
	}

	block1, block2, block3 := makeScBlock(1), makeScBlock(2), makeScBlock(3)

	t0 := time.Now()
	tick := make([]time.Time, 100)
	for i := range tick {
		tick[i] = t0.Add(time.Duration(i) * time.Millisecond)
	}

	type args struct {
		event Event
	}
	type scStep struct {
		currentSc *scTestParams
		args      args
		wantEvent Event
		wantErr   bool
		wantSc    *scTestParams
	}
	tests := []struct {
		name  string
		steps []scStep
	}{
		{
			name: "unknown event",
			steps: []scStep{
				{ // add P1
					currentSc: &scTestParams{},
					args:      args{event: unknownEv{}},
					wantEvent: scSchedulerFail{reason: fmt.Errorf("some error")},
					wantSc:    &scTestParams{},
				},
			},
		},
		{
			name: "single peer, sync 3 blocks",
			steps: []scStep{
				{ // add P1
					currentSc: &scTestParams{startTime: now, peers: map[string]*scPeer{}, height: 1},
					args:      args{event: bcAddNewPeer{peerID: "P1"}},
					wantEvent: noOpEvent{},
					wantSc: &scTestParams{startTime: now, peers: map[string]*scPeer{
						"P1": {base: -1, height: -1, state: peerStateNew}}, height: 1},
				},
				{ // set height of P1
					args:      args{event: bcStatusResponse{peerID: "P1", time: tick[0], height: 3}},
					wantEvent: noOpEvent{},
					wantSc: &scTestParams{
						startTime: now,
						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
						allB:      []int64{1, 2, 3},
						height:    1,
					},
				},
				{ // schedule block 1
					args:      args{event: rTrySchedule{time: tick[1]}},
					wantEvent: scBlockRequest{peerID: "P1", height: 1},
					wantSc: &scTestParams{
						startTime:   now,
						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
						allB:        []int64{1, 2, 3},
						pending:     map[int64]p2p.NodeID{1: "P1"},
						pendingTime: map[int64]time.Time{1: tick[1]},
						height:      1,
					},
				},
				{ // schedule block 2
					args:      args{event: rTrySchedule{time: tick[2]}},
					wantEvent: scBlockRequest{peerID: "P1", height: 2},
					wantSc: &scTestParams{
						startTime:   now,
						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
						allB:        []int64{1, 2, 3},
						pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
						pendingTime: map[int64]time.Time{1: tick[1], 2: tick[2]},
						height:      1,
					},
				},
				{ // schedule block 3
					args:      args{event: rTrySchedule{time: tick[3]}},
					wantEvent: scBlockRequest{peerID: "P1", height: 3},
					wantSc: &scTestParams{
						startTime:   now,
						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
						allB:        []int64{1, 2, 3},
						pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1"},
						pendingTime: map[int64]time.Time{1: tick[1], 2: tick[2], 3: tick[3]},
						height:      1,
					},
				},
				{ // block response 1
					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[4], size: 100, block: block1}},
					wantEvent: scBlockReceived{peerID: "P1", block: block1},
					wantSc: &scTestParams{
						startTime:   now,
						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[4]}},
						allB:        []int64{1, 2, 3},
						pending:     map[int64]p2p.NodeID{2: "P1", 3: "P1"},
						pendingTime: map[int64]time.Time{2: tick[2], 3: tick[3]},
						received:    map[int64]p2p.NodeID{1: "P1"},
						height:      1,
					},
				},
				{ // block response 2
					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[5], size: 100, block: block2}},
					wantEvent: scBlockReceived{peerID: "P1", block: block2},
					wantSc: &scTestParams{
						startTime:   now,
						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[5]}},
						allB:        []int64{1, 2, 3},
						pending:     map[int64]p2p.NodeID{3: "P1"},
						pendingTime: map[int64]time.Time{3: tick[3]},
						received:    map[int64]p2p.NodeID{1: "P1", 2: "P1"},
						height:      1,
					},
				},
				{ // block response 3
					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[6], size: 100, block: block3}},
					wantEvent: scBlockReceived{peerID: "P1", block: block3},
					wantSc: &scTestParams{
						startTime: now,
						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
						allB:      []int64{1, 2, 3},
						received:  map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1"},
						height:    1,
					},
				},
				{ // processed block 1
					args:      args{event: pcBlockProcessed{peerID: p2p.NodeID("P1"), height: 1}},
					wantEvent: noOpEvent{},
					wantSc: &scTestParams{
						startTime: now,
						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
						allB:      []int64{2, 3},
						received:  map[int64]p2p.NodeID{2: "P1", 3: "P1"},
						height:    2,
					},
				},
				{ // processed block 2
					args:      args{event: pcBlockProcessed{peerID: p2p.NodeID("P1"), height: 2}},
					wantEvent: scFinishedEv{},
					wantSc: &scTestParams{
						startTime: now,
						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
						allB:      []int64{3},
						received:  map[int64]p2p.NodeID{3: "P1"},
						height:    3,
					},
				},
			},
		},
		{
			name: "block verification failure",
			steps: []scStep{
				{ // failure processing block 1
					currentSc: &scTestParams{
						startTime: now,
						peers: map[string]*scPeer{
							"P1": {height: 4, state: peerStateReady, lastTouched: tick[6]},
							"P2": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
						allB:     []int64{1, 2, 3, 4},
						received: map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1"},
						height:   1,
					},
					args:      args{event: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P1"}},
					wantEvent: noOpEvent{},
					wantSc: &scTestParams{
						startTime: now,
						peers: map[string]*scPeer{
							"P1": {height: 4, state: peerStateRemoved, lastTouched: tick[6]},
							"P2": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
						allB:     []int64{1, 2, 3},
						received: map[int64]p2p.NodeID{},
						height:   1,
					},
				},
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			var sc *scheduler
			for i, step := range tt.steps {
				// First step must always initialize the currentState as state.
				if step.currentSc != nil {
					sc = newTestScheduler(*step.currentSc)
				}
				if sc == nil {
					panic("Bad (initial?) step")
				}

				nextEvent, err := sc.handle(step.args.event)
				wantSc := newTestScheduler(*step.wantSc)

				t.Logf("step %d(%v): %s", i, step.args.event, sc)
				checkSameScheduler(t, wantSc, sc)

				checkScResults(t, step.wantErr, err, step.wantEvent, nextEvent)

				// Next step may use the wantedState as their currentState.
				sc = newTestScheduler(*step.wantSc)
			}
		})
	}
}