fix some tests

Author: acoshift

accounts/abi/bind/backends/simulated_test.go

@@ -129,7 +129,7 @@ func TestNewSimulatedBackend(t *testing.T) {
 		t.Errorf("expected sim blockchain config to equal params.AllEthashProtocolChanges, got %v", sim.config)
 	}
 
-	stateDB, _, _ := sim.blockchain.State()
+	stateDB, _ := sim.blockchain.State()
 	bal := stateDB.GetBalance(testAddr)
 	if bal.Cmp(expectedBal) != 0 {
 		t.Errorf("expected balance for test address not received. expected: %v actual: %v", expectedBal, bal)

cmd/clef/README.md

@@ -225,7 +225,6 @@ Response
      - `value` [number:optional]: amount of Wei to send with the transaction
      - `data` [data:optional]:  input data (transaction manager hash if transaction is private)
      - `nonce` [number]: account nonce
-     - `isPrivate` [boolean:optional]: whether the transaction is a Quorum private transaction
   3. method signature [string:optional]
      - The method signature, if present, is to aid decoding the calldata. Should consist of `methodname(paramtype,...)`, e.g. `transfer(uint256,address)`. The signer may use this data to parse the supplied calldata, and show the user. The data, however, is considered totally untrusted, and reliability is not expected.
 

cmd/geth/accountcmd_test.go

@@ -190,7 +190,6 @@ Fatal: could not decrypt key with given password
 }
 
 func TestUnlockFlag(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	geth := runMinimalGethWithRaftConsensus(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "js", "testdata/empty.js")
 	geth.Expect(`
@@ -212,8 +211,6 @@ Password: {{.InputLine "foobar"}}
 }
 
 func TestGethDoesntStartWithoutConfiguredConsensus(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
-
 	datadir := tmpDatadirWithKeystore(t)
 	geth := runGeth(t,
 		"--datadir", datadir, "--nat", "none", "--nodiscover", "--maxpeers", "0", "--port", "0")
@@ -225,8 +222,6 @@ func TestGethDoesntStartWithoutConfiguredConsensus(t *testing.T) {
 }
 
 func TestGethStartsWhenConsensusAndPrivateConfigAreConfigured(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
-
 	datadir := tmpDatadirWithKeystore(t)
 	geth := runGeth(t,
 		"--datadir", datadir, "--nat", "none", "--nodiscover", "--maxpeers", "0", "--port", "0", "--raft")
@@ -235,7 +230,6 @@ func TestGethStartsWhenConsensusAndPrivateConfigAreConfigured(t *testing.T) {
 }
 
 func TestUnlockFlagWrongPassword(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "js", "testdata/empty.js")
 	defer geth.ExpectExit()
@@ -253,7 +247,6 @@ Fatal: Failed to unlock account f466859ead1932d743d622cb74fc058882e8648a (could
 
 // https://github.com/ethereum/go-ethereum/issues/1785
 func TestUnlockFlagMultiIndex(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	geth := runMinimalGethWithRaftConsensus(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--unlock", "0,2", "js", "testdata/empty.js")
 	geth.Expect(`
@@ -278,7 +271,6 @@ Password: {{.InputLine "foobar"}}
 }
 
 func TestUnlockFlagPasswordFile(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	geth := runMinimalGethWithRaftConsensus(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--password", "testdata/passwords.txt", "--unlock", "0,2", "js", "testdata/empty.js")
 	geth.ExpectExit()
@@ -296,7 +288,6 @@ func TestUnlockFlagPasswordFile(t *testing.T) {
 }
 
 func TestUnlockFlagPasswordFileWrongPassword(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--password",
 		"testdata/wrong-passwords.txt", "--unlock", "0,2")
@@ -307,7 +298,6 @@ Fatal: Failed to unlock account 0 (could not decrypt key with given password)
 }
 
 func TestUnlockFlagAmbiguous(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	datadir := tmpDatadirWithKeystore(t)
 	store := filepath.Join("..", "..", "accounts", "keystore", "testdata", "dupes")
 	geth := runMinimalGethWithRaftConsensus(t, "--datadir", datadir, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
@@ -347,7 +337,6 @@ In order to avoid this warning, you need to remove the following duplicate key f
 }
 
 func TestUnlockFlagAmbiguousWrongPassword(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	store := filepath.Join("..", "..", "accounts", "keystore", "testdata", "dupes")
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--keystore",

cmd/geth/consolecmd_test.go

@@ -18,8 +18,6 @@ package main
 
 import (
 	"crypto/rand"
-	"crypto/tls"
-	"flag"
 	"io/ioutil"
 	"math/big"
 	"os"
@@ -30,10 +28,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/params"
-	testifyassert "github.com/stretchr/testify/assert"
-	"gopkg.in/urfave/cli.v1"
 )
 
 const (
@@ -87,7 +82,6 @@ func runMinimalGeth(t *testing.T, args ...string) *testgeth {
 // Tests that a node embedded within a console can be started up properly and
 // then terminated by closing the input stream.
 func TestConsoleWelcome(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	coinbase := "0x491937757d1b26e29c507b8d4c0b233c2747e68d"
 
 	datadir := setupIstanbul(t)
@@ -130,7 +124,6 @@ func TestAttachWelcome(t *testing.T) {
 		httpPort string
 		wsPort   string
 	)
-	defer SetResetPrivateConfig("ignore")()
 	// Configure the instance for IPC attachment
 	coinbase := "0x491937757d1b26e29c507b8d4c0b233c2747e68d"
 
@@ -166,7 +159,6 @@ func TestAttachWelcome(t *testing.T) {
 }
 
 func TestHTTPAttachWelcome(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	coinbase := "0x491937757d1b26e29c507b8d4c0b233c2747e68d"
 	port := strconv.Itoa(trulyRandInt(1024, 65536)) // Yeah, sometimes this will fail, sorry :P
 
@@ -183,7 +175,6 @@ func TestHTTPAttachWelcome(t *testing.T) {
 }
 
 func TestWSAttachWelcome(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	coinbase := "0x491937757d1b26e29c507b8d4c0b233c2747e68d"
 	port := strconv.Itoa(trulyRandInt(1024, 65536)) // Yeah, sometimes this will fail, sorry :P
 
@@ -266,57 +257,3 @@ func setupIstanbul(t *testing.T) string {
 
 	return datadir
 }
-
-func TestReadTLSClientConfig_whenCustomizeTLSCipherSuites(t *testing.T) {
-	assert := testifyassert.New(t)
-
-	flagSet := new(flag.FlagSet)
-	flagSet.Bool(utils.RPCClientTLSInsecureSkipVerify.Name, true, "")
-	flagSet.String(utils.RPCClientTLSCipherSuites.Name, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,  TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", "")
-	ctx := cli.NewContext(nil, flagSet, nil)
-
-	tlsConf, ok, err := readTLSClientConfig("https://arbitraryendpoint", ctx)
-
-	assert.NoError(err)
-	assert.True(ok, "has custom TLS client configuration")
-	assert.True(tlsConf.InsecureSkipVerify)
-	assert.Len(tlsConf.CipherSuites, 2)
-	assert.Contains(tlsConf.CipherSuites, tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384)
-	assert.Contains(tlsConf.CipherSuites, tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
-}
-
-func TestReadTLSClientConfig_whenTypicalTLS(t *testing.T) {
-	assert := testifyassert.New(t)
-
-	flagSet := new(flag.FlagSet)
-	ctx := cli.NewContext(nil, flagSet, nil)
-
-	tlsConf, ok, err := readTLSClientConfig("https://arbitraryendpoint", ctx)
-
-	assert.NoError(err)
-	assert.False(ok, "no custom TLS client configuration")
-	assert.Nil(tlsConf, "no custom TLS config is set")
-}
-
-func TestReadTLSClientConfig_whenTLSInsecureFlagSet(t *testing.T) {
-	assert := testifyassert.New(t)
-
-	flagSet := new(flag.FlagSet)
-	flagSet.Bool(utils.RPCClientTLSInsecureSkipVerify.Name, true, "")
-	ctx := cli.NewContext(nil, flagSet, nil)
-
-	tlsConf, ok, err := readTLSClientConfig("https://arbitraryendpoint", ctx)
-
-	assert.NoError(err)
-	assert.True(ok, "has custom TLS client configuration")
-	assert.True(tlsConf.InsecureSkipVerify)
-	assert.Len(tlsConf.CipherSuites, 0)
-}
-
-func SetResetPrivateConfig(value string) func() {
-	existingValue := os.Getenv("PRIVATE_CONFIG")
-	os.Setenv("PRIVATE_CONFIG", value)
-	return func() {
-		os.Setenv("PRIVATE_CONFIG", existingValue)
-	}
-}

cmd/geth/dao_test.go

@@ -105,7 +105,6 @@ func TestDAOForkBlockNewChain(t *testing.T) {
 }
 
 func testDAOForkBlockNewChain(t *testing.T, test int, genesis string, expectBlock *big.Int, expectVote bool) {
-	defer SetResetPrivateConfig("ignore")()
 	// Create a temporary data directory to use and inspect later
 	datadir := tmpdir(t)
 	defer os.RemoveAll(datadir)

cmd/geth/genesis_test.go

@@ -20,7 +20,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	"github.com/cespare/cp"
@@ -75,7 +74,6 @@ var customGenesisTests = []struct {
 // Tests that initializing Geth with a custom genesis block and chain definitions
 // work properly.
 func TestCustomGenesis(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	for i, tt := range customGenesisTests {
 		// Create a temporary data directory to use and inspect later
 		datadir := tmpdir(t)
@@ -107,7 +105,6 @@ func TestCustomGenesis(t *testing.T) {
 }
 
 func TestCustomGenesisUpgradeWithPrivacyEnhancementsBlock(t *testing.T) {
-	defer SetResetPrivateConfig("ignore")()
 	// Create a temporary data directory to use and inspect later
 	datadir := tmpdir(t)
 	defer os.RemoveAll(datadir)
@@ -145,45 +142,4 @@ func TestCustomGenesisUpgradeWithPrivacyEnhancementsBlock(t *testing.T) {
 	}
 	geth := runGeth(t, "--datadir", datadir, "init", json)
 	geth.WaitExit()
-
-	genesisContentWithPrivacyEnhancements :=
-		`{
-			"alloc"      : {},
-			"coinbase"   : "0x0000000000000000000000000000000000000000",
-			"difficulty" : "0x20000",
-			"extraData"  : "",
-			"gasLimit"   : "0x2fefd8",
-			"nonce"      : "0x0000000000000042",
-			"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-			"timestamp"  : "0x00",
-			"config"     : {
-				"homesteadBlock" : 42,
-				"daoForkBlock"   : 141,
-				"privacyEnhancementsBlock"   : 1000,
-				"daoForkSupport" : true,
-				"isQuorum" : false
-			}
-		}`
-
-	if err := ioutil.WriteFile(json, []byte(genesisContentWithPrivacyEnhancements), 0600); err != nil {
-		t.Fatalf("failed to write genesis file: %v", err)
-	}
-	geth = runGeth(t, "--datadir", datadir, "init", json)
-	geth.WaitExit()
-
-	expectedText := "Privacy enhancements have been enabled from block height 1000. Please ensure your privacy manager is upgraded and supports privacy enhancements"
-
-	result := strings.TrimSpace(geth.StderrText())
-	if !strings.Contains(result, expectedText) {
-		geth.Fatalf("bad stderr text. want '%s', got '%s'", expectedText, result)
-	}
-
-	// start quorum - it should fail the transaction manager PrivacyEnhancements feature validation
-	geth = runGeth(t,
-		"--datadir", datadir, "--maxpeers", "0", "--port", "0",
-		"--nodiscover", "--nat", "none", "--ipcdisable",
-		"--raft", "console")
-	geth.ExpectRegexp("Cannot start quorum with privacy enhancements enabled while the transaction manager does not support it")
-	geth.ExpectExit()
 }

consensus/clique/snapshot_test.go

@@ -448,7 +448,7 @@ func TestClique(t *testing.T) {
 			batches[len(batches)-1] = append(batches[len(batches)-1], block)
 		}
 		// Pass all the headers through clique and ensure tallying succeeds
-		chain, err := core.NewBlockChain(db, nil, &config, engine, vm.Config{}, nil, nil, nil)
+		chain, err := core.NewBlockChain(db, nil, &config, engine, vm.Config{}, nil, nil)
 		if err != nil {
 			t.Errorf("test %d: failed to create test chain: %v", i, err)
 			continue

core/bench_test.go

@@ -176,7 +176,7 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 
 	// Time the insertion of the new chain.
 	// State and blocks are stored in the same DB.
-	chainman, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
+	chainman, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{}, nil, nil)
 	defer chainman.Stop()
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -288,7 +288,7 @@ func benchReadChain(b *testing.B, full bool, count uint64) {
 		if err != nil {
 			b.Fatalf("error opening database at %v: %v", dir, err)
 		}
-		chain, err := NewBlockChain(db, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
+		chain, err := NewBlockChain(db, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil)
 		if err != nil {
 			b.Fatalf("error creating chain: %v", err)
 		}

core/block_validator_test.go

@@ -42,7 +42,7 @@ func TestHeaderVerification(t *testing.T) {
 		headers[i] = block.Header()
 	}
 	// Run the header checker for blocks one-by-one, checking for both valid and invalid nonces
-	chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
+	chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil)
 	defer chain.Stop()
 
 	for i := 0; i < len(blocks); i++ {
@@ -106,11 +106,11 @@ func testHeaderConcurrentVerification(t *testing.T, threads int) {
 		var results <-chan error
 
 		if valid {
-			chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
+			chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{}, nil, nil)
 			_, results = chain.engine.VerifyHeaders(chain, headers, seals)
 			chain.Stop()
 		} else {
-			chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFakeFailer(uint64(len(headers)-1)), vm.Config{}, nil, nil, nil)
+			chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFakeFailer(uint64(len(headers)-1)), vm.Config{}, nil, nil)
 			_, results = chain.engine.VerifyHeaders(chain, headers, seals)
 			chain.Stop()
 		}
@@ -173,7 +173,7 @@ func testHeaderConcurrentAbortion(t *testing.T, threads int) {
 	defer runtime.GOMAXPROCS(old)
 
 	// Start the verifications and immediately abort
-	chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFakeDelayer(time.Millisecond), vm.Config{}, nil, nil, nil)
+	chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFakeDelayer(time.Millisecond), vm.Config{}, nil, nil)
 	defer chain.Stop()
 
 	abort, results := chain.engine.VerifyHeaders(chain, headers, seals)

core/blockchain_repair_test.go

@@ -1752,7 +1752,7 @@ func testLongReorgedFastSyncingDeepRepair(t *testing.T, snapshots bool) {
 
 func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
 	// It's hard to follow the test case, visualize the input
-	//log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
+	// log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
 	// fmt.Println(tt.dump(true))
 
 	// Create a temporary persistent database
@@ -1783,7 +1783,7 @@ func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
 		config.SnapshotLimit = 256
 		config.SnapshotWait = true
 	}
-	chain, err := NewBlockChain(db, config, params.AllEthashProtocolChanges, engine, vm.Config{}, nil, nil, nil)
+	chain, err := NewBlockChain(db, config, params.AllEthashProtocolChanges, engine, vm.Config{}, nil, nil)
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)
 	}
@@ -1836,7 +1836,7 @@ func testRepair(t *testing.T, tt *rewindTest, snapshots bool) {
 	}
 	defer db.Close()
 
-	chain, err = NewBlockChain(db, nil, params.AllEthashProtocolChanges, engine, vm.Config{}, nil, nil, nil)
+	chain, err = NewBlockChain(db, nil, params.AllEthashProtocolChanges, engine, vm.Config{}, nil, nil)
 	if err != nil {
 		t.Fatalf("Failed to recreate chain: %v", err)
 	}