path: root/eth/handler_test.go

// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package eth

import (
    "fmt"
    "math"
    "math/big"
    "math/rand"
    "testing"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/consensus/ethash"
    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/rawdb"
    "github.com/ethereum/go-ethereum/core/state"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/core/vm"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/eth/downloader"
    "github.com/ethereum/go-ethereum/event"
    "github.com/ethereum/go-ethereum/p2p"
    "github.com/ethereum/go-ethereum/params"
)

// Tests that protocol versions and modes of operations are matched up properly.
func TestProtocolCompatibility(t *testing.T) {
    // Define the compatibility chart
    tests := []struct {
        version    uint
        mode       downloader.SyncMode
        compatible bool
    }{
        {61, downloader.FullSync, true}, {62, downloader.FullSync, true}, {63, downloader.FullSync, true},
        {61, downloader.FastSync, false}, {62, downloader.FastSync, false}, {63, downloader.FastSync, true},
    }
    // Make sure anything we screw up is restored
    backup := ProtocolVersions
    defer func() { ProtocolVersions = backup }()

    // Try all available compatibility configs and check for errors
    for i, tt := range tests {
        ProtocolVersions = []uint{tt.version}

        pm, _, err := newTestProtocolManager(tt.mode, 0, nil, nil)
        if pm != nil {
            defer pm.Stop()
        }
        if (err == nil && !tt.compatible) || (err != nil && tt.compatible) {
            t.Errorf("test %d: compatibility mismatch: have error %v, want compatibility %v", i, err, tt.compatible)
        }
    }
}

// Tests that block headers can be retrieved from a remote chain based on user queries.
func TestGetBlockHeaders62(t *testing.T) { testGetBlockHeaders(t, 62) }
func TestGetBlockHeaders63(t *testing.T) { testGetBlockHeaders(t, 63) }

func testGetBlockHeaders(t *testing.T, protocol int) {
    pm, _ := newTestProtocolManagerMust(t, downloader.FullSync, downloader.MaxHashFetch+15, nil, nil)
    peer, _ := newTestPeer("peer", protocol, pm, true)
    defer peer.close()

    // Create a "random" unknown hash for testing
    var unknown common.Hash
    for i := range unknown {
        unknown[i] = byte(i)
    }
    // Create a batch of tests for various scenarios
    limit := uint64(downloader.MaxHeaderFetch)
    tests := []struct {
        query  *getBlockHeadersData // The query to execute for header retrieval
        expect []common.Hash        // The hashes of the block whose headers are expected
    }{
        // A single random block should be retrievable by hash and number too
        {
            &getBlockHeadersData{Origin: hashOrNumber{Hash: pm.blockchain.GetBlockByNumber(limit / 2).Hash()}, Amount: 1},
            []common.Hash{pm.blockchain.GetBlockByNumber(limit / 2).Hash()},
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 1},
            []common.Hash{pm.blockchain.GetBlockByNumber(limit / 2).Hash()},
        },
        // Multiple headers should be retrievable in both directions
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 3},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(limit / 2).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 + 1).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 + 2).Hash(),
            },
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 3, Reverse: true},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(limit / 2).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 - 1).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 - 2).Hash(),
            },
        },
        // Multiple headers with skip lists should be retrievable
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Skip: 3, Amount: 3},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(limit / 2).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 + 4).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 + 8).Hash(),
            },
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Skip: 3, Amount: 3, Reverse: true},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(limit / 2).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 - 4).Hash(),
                pm.blockchain.GetBlockByNumber(limit/2 - 8).Hash(),
            },
        },
        // The chain endpoints should be retrievable
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: 0}, Amount: 1},
            []common.Hash{pm.blockchain.GetBlockByNumber(0).Hash()},
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: pm.blockchain.CurrentBlock().NumberU64()}, Amount: 1},
            []common.Hash{pm.blockchain.CurrentBlock().Hash()},
        },
        // Ensure protocol limits are honored
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: pm.blockchain.CurrentBlock().NumberU64() - 1}, Amount: limit + 10, Reverse: true},
            pm.blockchain.GetBlockHashesFromHash(pm.blockchain.CurrentBlock().Hash(), limit),
        },
        // Check that requesting more than available is handled gracefully
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: pm.blockchain.CurrentBlock().NumberU64() - 4}, Skip: 3, Amount: 3},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(pm.blockchain.CurrentBlock().NumberU64() - 4).Hash(),
                pm.blockchain.GetBlockByNumber(pm.blockchain.CurrentBlock().NumberU64()).Hash(),
            },
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: 4}, Skip: 3, Amount: 3, Reverse: true},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(4).Hash(),
                pm.blockchain.GetBlockByNumber(0).Hash(),
            },
        },
        // Check that requesting more than available is handled gracefully, even if mid skip
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: pm.blockchain.CurrentBlock().NumberU64() - 4}, Skip: 2, Amount: 3},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(pm.blockchain.CurrentBlock().NumberU64() - 4).Hash(),
                pm.blockchain.GetBlockByNumber(pm.blockchain.CurrentBlock().NumberU64() - 1).Hash(),
            },
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: 4}, Skip: 2, Amount: 3, Reverse: true},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(4).Hash(),
                pm.blockchain.GetBlockByNumber(1).Hash(),
            },
        },
        // Check a corner case where requesting more can iterate past the endpoints
        {
            &getBlockHeadersData{Origin: hashOrNumber{Number: 2}, Amount: 5, Reverse: true},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(2).Hash(),
                pm.blockchain.GetBlockByNumber(1).Hash(),
                pm.blockchain.GetBlockByNumber(0).Hash(),
            },
        },
        // Check a corner case where skipping overflow loops back into the chain start
        {
            &getBlockHeadersData{Origin: hashOrNumber{Hash: pm.blockchain.GetBlockByNumber(3).Hash()}, Amount: 2, Reverse: false, Skip: math.MaxUint64 - 1},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(3).Hash(),
            },
        },
        // Check a corner case where skipping overflow loops back to the same header
        {
            &getBlockHeadersData{Origin: hashOrNumber{Hash: pm.blockchain.GetBlockByNumber(1).Hash()}, Amount: 2, Reverse: false, Skip: math.MaxUint64},
            []common.Hash{
                pm.blockchain.GetBlockByNumber(1).Hash(),
            },
        },
        // Check that non existing headers aren't returned
        {
            &getBlockHeadersData{Origin: hashOrNumber{Hash: unknown}, Amount: 1},
            []common.Hash{},
        }, {
            &getBlockHeadersData{Origin: hashOrNumber{Number: pm.blockchain.CurrentBlock().NumberU64() + 1}, Amount: 1},
            []common.Hash{},
        },
    }
    // Run each of the tests and verify the results against the chain
    for i, tt := range tests {
        // Collect the headers to expect in the response
        headers := []*types.Header{}
        for _, hash := range tt.expect {
            headers = append(headers, pm.blockchain.GetBlockByHash(hash).Header())
        }
        // Send the hash request and verify the response
        p2p.Send(peer.app, 0x03, tt.query)
        if err := p2p.ExpectMsg(peer.app, 0x04, headers); err != nil {
            t.Errorf("test %d: headers mismatch: %v", i, err)
        }
        // If the test used number origins, repeat with hashes as the too
        if tt.query.Origin.Hash == (common.Hash{}) {
            if origin := pm.blockchain.GetBlockByNumber(tt.query.Origin.Number); origin != nil {
                tt.query.Origin.Hash, tt.query.Origin.Number = origin.Hash(), 0

                p2p.Send(peer.app, 0x03, tt.query)
                if err := p2p.ExpectMsg(peer.app, 0x04, headers); err != nil {
                    t.Errorf("test %d: headers mismatch: %v", i, err)
                }
            }
        }
    }
}

// Tests that block contents can be retrieved from a remote chain based on their hashes.
func TestGetBlockBodies62(t *testing.T) { testGetBlockBodies(t, 62) }
func TestGetBlockBodies63(t *testing.T) { testGetBlockBodies(t, 63) }

func testGetBlockBodies(t *testing.T, protocol int) {
    pm, _ := newTestProtocolManagerMust(t, downloader.FullSync, downloader.MaxBlockFetch+15, nil, nil)
    peer, _ := newTestPeer("peer", protocol, pm, true)
    defer peer.close()

    // Create a batch of tests for various scenarios
    limit := downloader.MaxBlockFetch
    tests := []struct {
        random    int           // Number of blocks to fetch randomly from the chain
        explicit  []common.Hash // Explicitly requested blocks
        available []bool        // Availability of explicitly requested blocks
        expected  int           // Total number of existing blocks to expect
    }{
        {1, nil, nil, 1},             // A single random block should be retrievable
        {10, nil, nil, 10},           // Multiple random blocks should be retrievable
        {limit, nil, nil, limit},     // The maximum possible blocks should be retrievable
        {limit + 1, nil, nil, limit}, // No more than the possible block count should be returned
        {0, []common.Hash{pm.blockchain.Genesis().Hash()}, []bool{true}, 1},      // The genesis block should be retrievable
        {0, []common.Hash{pm.blockchain.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
        {0, []common.Hash{{}}, []bool{false}, 0},                                 // A non existent block should not be returned

        // Existing and non-existing blocks interleaved should not cause problems
        {0, []common.Hash{
            {},
            pm.blockchain.GetBlockByNumber(1).Hash(),
            {},
            pm.blockchain.GetBlockByNumber(10).Hash(),
            {},
            pm.blockchain.GetBlockByNumber(100).Hash(),
            {},
        }, []bool{false, true, false, true, false, true, false}, 3},
    }
    // Run each of the tests and verify the results against the chain
    for i, tt := range tests {
        // Collect the hashes to request, and the response to expect
        hashes, seen := []common.Hash{}, make(map[int64]bool)
        bodies := []*blockBody{}

        for j := 0; j < tt.random; j++ {
            for {
                num := rand.Int63n(int64(pm.blockchain.CurrentBlock().NumberU64()))
                if !seen[num] {
                    seen[num] = true

                    block := pm.blockchain.GetBlockByNumber(uint64(num))
                    hashes = append(hashes, block.Hash())
                    if len(bodies) < tt.expected {
                        bodies = append(bodies, &blockBody{Transactions: block.Transactions(), Uncles: block.Uncles()})
                    }
                    break
                }
            }
        }
        for j, hash := range tt.explicit {
            hashes = append(hashes, hash)
            if tt.available[j] && len(bodies) < tt.expected {
                block := pm.blockchain.GetBlockByHash(hash)
                bodies = append(bodies, &blockBody{Transactions: block.Transactions(), Uncles: block.Uncles()})
            }
        }
        // Send the hash request and verify the response
        p2p.Send(peer.app, 0x05, hashes)
        if err := p2p.ExpectMsg(peer.app, 0x06, bodies); err != nil {
            t.Errorf("test %d: bodies mismatch: %v", i, err)
        }
    }
}

// Tests that the node state database can be retrieved based on hashes.
func TestGetNodeData63(t *testing.T) { testGetNodeData(t, 63) }

func testGetNodeData(t *testing.T, protocol int) {
    // Define three accounts to simulate transactions with
    acc1Key, _ := crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
    acc2Key, _ := crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
    acc1Addr := crypto.PubkeyToAddress(acc1Key.PublicKey)
    acc2Addr := crypto.PubkeyToAddress(acc2Key.PublicKey)

    signer := types.HomesteadSigner{}
    // Create a chain generator with some simple transactions (blatantly stolen from @fjl/chain_markets_test)
    generator := func(i int, block *core.BlockGen) {
        switch i {
        case 0:
            // In block 1, the test bank sends account #1 some ether.
            tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey)
            block.AddTx(tx)
        case 1:
            // In block 2, the test bank sends some more ether to account #1.
            // acc1Addr passes it on to account #2.
            tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey)
            tx2, _ := types.SignTx(types.NewTransaction(block.TxNonce(acc1Addr), acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key)
            block.AddTx(tx1)
            block.AddTx(tx2)
        case 2:
            // Block 3 is empty but was mined by account #2.
            block.SetCoinbase(acc2Addr)
            block.SetExtra([]byte("yeehaw"))
        case 3:
            // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data).
            b2 := block.PrevBlock(1).Header()
            b2.Extra = []byte("foo")
            block.AddUncle(b2)
            b3 := block.PrevBlock(2).Header()
            b3.Extra = []byte("foo")
            block.AddUncle(b3)
        }
    }
    // Assemble the test environment
    pm, db := newTestProtocolManagerMust(t, downloader.FullSync, 4, generator, nil)
    peer, _ := newTestPeer("peer", protocol, pm, true)
    defer peer.close()

    // Fetch for now the entire chain db
    hashes := []common.Hash{}

    it := db.NewIterator()
    for it.Next() {
        if key := it.Key(); len(key) == common.HashLength {
            hashes = append(hashes, common.BytesToHash(key))
        }
    }
    it.Release()

    p2p.Send(peer.app, 0x0d, hashes)
    msg, err := peer.app.ReadMsg()
    if err != nil {
        t.Fatalf("failed to read node data response: %v", err)
    }
    if msg.Code != 0x0e {
        t.Fatalf("response packet code mismatch: have %x, want %x", msg.Code, 0x0c)
    }
    var data [][]byte
    if err := msg.Decode(&data); err != nil {
        t.Fatalf("failed to decode response node data: %v", err)
    }
    // Verify that all hashes correspond to the requested data, and reconstruct a state tree
    for i, want := range hashes {
        if hash := crypto.Keccak256Hash(data[i]); hash != want {
            t.Errorf("data hash mismatch: have %x, want %x", hash, want)
        }
    }
    statedb := rawdb.NewMemoryDatabase()
    for i := 0; i < len(data); i++ {
        statedb.Put(hashes[i].Bytes(), data[i])
    }
    accounts := []common.Address{testBank, acc1Addr, acc2Addr}
    for i := uint64(0); i <= pm.blockchain.CurrentBlock().NumberU64(); i++ {
        trie, _ := state.New(pm.blockchain.GetBlockByNumber(i).Root(), state.NewDatabase(statedb))

        for j, acc := range accounts {
            state, _ := pm.blockchain.State()
            bw := state.GetBalance(acc)
            bh := trie.GetBalance(acc)

            if (bw != nil && bh == nil) || (bw == nil && bh != nil) {
                t.Errorf("test %d, account %d: balance mismatch: have %v, want %v", i, j, bh, bw)
            }
            if bw != nil && bh != nil && bw.Cmp(bw) != 0 {
                t.Errorf("test %d, account %d: balance mismatch: have %v, want %v", i, j, bh, bw)
            }
        }
    }
}

// Tests that the transaction receipts can be retrieved based on hashes.
func TestGetReceipt63(t *testing.T) { testGetReceipt(t, 63) }

func testGetReceipt(t *testing.T, protocol int) {
    // Define three accounts to simulate transactions with
    acc1Key, _ := crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
    acc2Key, _ := crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
    acc1Addr := crypto.PubkeyToAddress(acc1Key.PublicKey)
    acc2Addr := crypto.PubkeyToAddress(acc2Key.PublicKey)

    signer := types.HomesteadSigner{}
    // Create a chain generator with some simple transactions (blatantly stolen from @fjl/chain_markets_test)
    generator := func(i int, block *core.BlockGen) {
        switch i {
        case 0:
            // In block 1, the test bank sends account #1 some ether.
            tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey)
            block.AddTx(tx)
        case 1:
            // In block 2, the test bank sends some more ether to account #1.
            // acc1Addr passes it on to account #2.
            tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey)
            tx2, _ := types.SignTx(types.NewTransaction(block.TxNonce(acc1Addr), acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key)
            block.AddTx(tx1)
            block.AddTx(tx2)
        case 2:
            // Block 3 is empty but was mined by account #2.
            block.SetCoinbase(acc2Addr)
            block.SetExtra([]byte("yeehaw"))
        case 3:
            // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data).
            b2 := block.PrevBlock(1).Header()
            b2.Extra = []byte("foo")
            block.AddUncle(b2)
            b3 := block.PrevBlock(2).Header()
            b3.Extra = []byte("foo")
            block.AddUncle(b3)
        }
    }
    // Assemble the test environment
    pm, _ := newTestProtocolManagerMust(t, downloader.FullSync, 4, generator, nil)
    peer, _ := newTestPeer("peer", protocol, pm, true)
    defer peer.close()

    // Collect the hashes to request, and the response to expect
    hashes, receipts := []common.Hash{}, []types.Receipts{}
    for i := uint64(0); i <= pm.blockchain.CurrentBlock().NumberU64(); i++ {
        block := pm.blockchain.GetBlockByNumber(i)

        hashes = append(hashes, block.Hash())
        receipts = append(receipts, pm.blockchain.GetReceiptsByHash(block.Hash()))
    }
    // Send the hash request and verify the response
    p2p.Send(peer.app, 0x0f, hashes)
    if err := p2p.ExpectMsg(peer.app, 0x10, receipts); err != nil {
        t.Errorf("receipts mismatch: %v", err)
    }
}

// Tests that post eth protocol handshake, clients perform a mutual checkpoint
// challenge to validate each other's chains. Hash mismatches, or missing ones
// during a fast sync should lead to the peer getting dropped.
func TestCheckpointChallenge(t *testing.T) {
    tests := []struct {
        syncmode   downloader.SyncMode
        checkpoint bool
        timeout    bool
        empty      bool
        match      bool
        drop       bool
    }{
        // If checkpointing is not enabled locally, don't challenge and don't drop
        {downloader.FullSync, false, false, false, false, false},
        {downloader.FastSync, false, false, false, false, false},

        // If checkpointing is enabled locally and remote response is empty, only drop during fast sync
        {downloader.FullSync, true, false, true, false, false},
        {downloader.FastSync, true, false, true, false, true}, // Special case, fast sync, unsynced peer

        // If checkpointing is enabled locally and remote response mismatches, always drop
        {downloader.FullSync, true, false, false, false, true},
        {downloader.FastSync, true, false, false, false, true},

        // If checkpointing is enabled locally and remote response matches, never drop
        {downloader.FullSync, true, false, false, true, false},
        {downloader.FastSync, true, false, false, true, false},

        // If checkpointing is enabled locally and remote times out, always drop
        {downloader.FullSync, true, true, false, true, true},
        {downloader.FastSync, true, true, false, true, true},
    }
    for _, tt := range tests {
        t.Run(fmt.Sprintf("sync %v checkpoint %v timeout %v empty %v match %v", tt.syncmode, tt.checkpoint, tt.timeout, tt.empty, tt.match), func(t *testing.T) {
            testCheckpointChallenge(t, tt.syncmode, tt.checkpoint, tt.timeout, tt.empty, tt.match, tt.drop)
        })
    }
}

func testCheckpointChallenge(t *testing.T, syncmode downloader.SyncMode, checkpoint bool, timeout bool, empty bool, match bool, drop bool) {
    // Reduce the checkpoint handshake challenge timeout
    defer func(old time.Duration) { syncChallengeTimeout = old }(syncChallengeTimeout)
    syncChallengeTimeout = 250 * time.Millisecond

    // Initialize a chain and generate a fake CHT if checkpointing is enabled
    var (
        db      = rawdb.NewMemoryDatabase()
        config  = new(params.ChainConfig)
        genesis = (&core.Genesis{Config: config}).MustCommit(db)
    )
    // If checkpointing is enabled, create and inject a fake CHT and the corresponding
    // chllenge response.
    var response *types.Header
    if checkpoint {
        index := uint64(rand.Intn(500))
        number := (index+1)*params.CHTFrequency - 1
        response = &types.Header{Number: big.NewInt(int64(number)), Extra: []byte("valid")}

        cht := &params.TrustedCheckpoint{
            SectionIndex: index,
            SectionHead:  response.Hash(),
        }
        params.TrustedCheckpoints[genesis.Hash()] = cht
        defer delete(params.TrustedCheckpoints, genesis.Hash())
    }
    // Create a checkpoint aware protocol manager
    blockchain, err := core.NewBlockChain(db, nil, config, ethash.NewFaker(), vm.Config{}, nil)
    if err != nil {
        t.Fatalf("failed to create new blockchain: %v", err)
    }
    pm, err := NewProtocolManager(config, syncmode, DefaultConfig.NetworkId, new(event.TypeMux), new(testTxPool), ethash.NewFaker(), blockchain, db, 1, nil)
    if err != nil {
        t.Fatalf("failed to start test protocol manager: %v", err)
    }
    pm.Start(1000)
    defer pm.Stop()

    // Connect a new peer and check that we receive the checkpoint challenge
    peer, _ := newTestPeer("peer", eth63, pm, true)
    defer peer.close()

    if checkpoint {
        challenge := &getBlockHeadersData{
            Origin:  hashOrNumber{Number: response.Number.Uint64()},
            Amount:  1,
            Skip:    0,
            Reverse: false,
        }
        if err := p2p.ExpectMsg(peer.app, GetBlockHeadersMsg, challenge); err != nil {
            t.Fatalf("challenge mismatch: %v", err)
        }
        // Create a block to reply to the challenge if no timeout is simulated
        if !timeout {
            if empty {
                if err := p2p.Send(peer.app, BlockHeadersMsg, []*types.Header{}); err != nil {
                    t.Fatalf("failed to answer challenge: %v", err)
                }
            } else if match {
                if err := p2p.Send(peer.app, BlockHeadersMsg, []*types.Header{response}); err != nil {
                    t.Fatalf("failed to answer challenge: %v", err)
                }
            } else {
                if err := p2p.Send(peer.app, BlockHeadersMsg, []*types.Header{{Number: response.Number}}); err != nil {
                    t.Fatalf("failed to answer challenge: %v", err)
                }
            }
        }
    }
    // Wait until the test timeout passes to ensure proper cleanup
    time.Sleep(syncChallengeTimeout + 100*time.Millisecond)

    // Verify that the remote peer is maintained or dropped
    if drop {
        if peers := pm.peers.Len(); peers != 0 {
            t.Fatalf("peer count mismatch: have %d, want %d", peers, 0)
        }
    } else {
        if peers := pm.peers.Len(); peers != 1 {
            t.Fatalf("peer count mismatch: have %d, want %d", peers, 1)
        }
    }
}

func TestBroadcastBlock(t *testing.T) {
    var tests = []struct {
        totalPeers        int
        broadcastExpected int
    }{
        {1, 1},
        {2, 2},
        {3, 3},
        {4, 4},
        {5, 4},
        {9, 4},
        {12, 4},
        {16, 4},
        {26, 5},
        {100, 10},
    }
    for _, test := range tests {
        testBroadcastBlock(t, test.totalPeers, test.broadcastExpected)
    }
}

func testBroadcastBlock(t *testing.T, totalPeers, broadcastExpected int) {
    var (
        evmux   = new(event.TypeMux)
        pow     = ethash.NewFaker()
        db      = rawdb.NewMemoryDatabase()
        config  = &params.ChainConfig{}
        gspec   = &core.Genesis{Config: config}
        genesis = gspec.MustCommit(db)
    )
    blockchain, err := core.NewBlockChain(db, nil, config, pow, vm.Config{}, nil)
    if err != nil {
        t.Fatalf("failed to create new blockchain: %v", err)
    }
    pm, err := NewProtocolManager(config, downloader.FullSync, DefaultConfig.NetworkId, evmux, new(testTxPool), pow, blockchain, db, 1, nil)
    if err != nil {
        t.Fatalf("failed to start test protocol manager: %v", err)
    }
    pm.Start(1000)
    defer pm.Stop()
    var peers []*testPeer
    for i := 0; i < totalPeers; i++ {
        peer, _ := newTestPeer(fmt.Sprintf("peer %d", i), eth63, pm, true)
        defer peer.close()
        peers = append(peers, peer)
    }
    chain, _ := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 1, func(i int, gen *core.BlockGen) {})
    pm.BroadcastBlock(chain[0], true /*propagate*/)

    errCh := make(chan error, totalPeers)
    doneCh := make(chan struct{}, totalPeers)
    for _, peer := range peers {
        go func(p *testPeer) {
            if err := p2p.ExpectMsg(p.app, NewBlockMsg, &newBlockData{Block: chain[0], TD: big.NewInt(131136)}); err != nil {
                errCh <- err
            } else {
                doneCh <- struct{}{}
            }
        }(peer)
    }
    timeout := time.After(300 * time.Millisecond)
    var receivedCount int
outer:
    for {
        select {
        case err = <-errCh:
            break outer
        case <-doneCh:
            receivedCount++
            if receivedCount == totalPeers {
                break outer
            }
        case <-timeout:
            break outer
        }
    }
    for _, peer := range peers {
        peer.app.Close()
    }
    if err != nil {
        t.Errorf("error matching block by peer: %v", err)
    }
    if receivedCount != broadcastExpected {
        t.Errorf("block broadcast to %d peers, expected %d", receivedCount, broadcastExpected)
    }
}