Function testHeaderConcurrentAbortion

core/block_validator_test.go:177–230

(t *testing.T, threads int)

func TestHeaderConcurrentAbortion32(t *testing.T) { testHeaderConcurrentAbortion(t, 32) }

func testHeaderConcurrentAbortion(t *testing.T, threads int) {
	// Create a simple chain to verify

	var (
		testdb = database.NewMemDatabase()
	)

	genesis := DefaultGenesisBlock()
	genesisBlock := genesis.MustCommit(testdb)

	remoteDB := database.NewIpfsDbWithAdapter(database.NewFakeIpfsAdapter())

	config := configs.ChainConfigInfo().Dpor
	d := dpor.NewFaker(config, testdb)

	blocks, _ := GenerateChain(genesis.Config, genesisBlock, d, testdb, remoteDB, 8, nil)

	headers := make([]*types.Header, len(blocks))
	seals := make([]bool, len(blocks))

	for i, block := range blocks {
		headers[i] = block.Header()
		seals[i] = true
	}
	// Set the number of threads to verify on
	old := runtime.GOMAXPROCS(threads)
	defer runtime.GOMAXPROCS(old)

	engine := dpor.NewFakeDelayer(config, testdb, time.Millisecond)
	// Start the verifications and immediately abort
	chain, _ := NewBlockChain(testdb, nil, genesis.Config, engine, vm.Config{}, remoteDB, nil)
	defer chain.Stop()

	abort, results := chain.engine.VerifyHeaders(chain, headers, seals, headers)
	close(abort)

	// Deplete the results channel
	verified := 0
	for depleted := false; !depleted; {
		select {
		case result := <-results:
			if result != nil {
				t.Errorf("header %d: validation failed: %v", verified, result)
			}
			verified++
		case <-time.After(50 * time.Millisecond):
			depleted = true
		}
	}
	// Check that abortion was honored by not processing too many POWs
	if verified > 3*threads {
		t.Errorf("verification count too large: have %d, want below %d", verified, 3*threads)
	}
}