tests: update tests and implement general state tests (#14734)

Tests are now included as a submodule. This should make updating easier
and removes ~60MB of JSON data from the working copy.

State tests are replaced by General State Tests, which run the same test
with multiple fork configurations.

With the new test runner, consensus tests are run as subtests by walking
json files. Many hex issues have been fixed upstream since the last
update and most custom parsing code is replaced by existing JSON hex
types. Tests can now be marked as 'expected failures', ensuring that
fixes for those tests will trigger an update to test configuration. The
new test runner also supports parallel execution and the -short flag.

1 files changed, 57 insertions, 955 deletions

diff --git a/tests/state_test.go b/tests/state_test.go
index 29180942b..e4e691589 100644
--- a/tests/state_test.go
+++ b/tests/state_test.go
@@ -1,4 +1,4 @@
-// Copyright 2015 The go-ethereum Authors
+// Copyright 2017 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
@@ -17,970 +17,72 @@
 package tests
 
 import (
-	"math/big"
-	"os"
-	"path/filepath"
+	"bytes"
+	"fmt"
+	"reflect"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/core/vm"
 )
 
-func BenchmarkStateCall1024(b *testing.B) {
-	fn := filepath.Join(stateTestDir, "stCallCreateCallCodeTest.json")
-	if err := BenchVmTest(fn, bconf{"Call1024BalanceTooLow", true, os.Getenv("JITVM") == "true"}, b); err != nil {
-		b.Error(err)
-	}
-}
-
-func TestStateSystemOperations(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stSystemOperationsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateExample(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stExample.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStatePreCompiledContracts(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stPreCompiledContracts.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateRecursiveCreate(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stRecursiveCreate.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateSpecial(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stSpecialTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateRefund(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stRefundTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateBlockHash(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stBlockHashTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateInitCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stInitCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateLog(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stLogTests.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateTransaction(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stTransactionTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateTransition(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stTransitionTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestCallCreateCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stCallCreateCallCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestCallCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stCallCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMemory(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stMemoryTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMemoryStress(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "stMemoryStressTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestQuadraticComplexity(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "stQuadraticComplexityTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestSolidity(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stSolidityTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestWallet(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "stWalletTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestStateTestsRandom(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fns, _ := filepath.Glob("./files/StateTests/RandomTests/*")
-	for _, fn := range fns {
-		t.Log("running:", fn)
-		if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-			t.Error(fn, err)
+func TestState(t *testing.T) {
+	t.Parallel()
+
+	st := new(testMatcher)
+	// Long tests:
+	st.skipShortMode(`^stQuadraticComplexityTest/`)
+	// Broken tests:
+	st.skipLoad(`^stTransactionTest/OverflowGasRequire\.json`) // gasLimit > 256 bits
+	st.skipLoad(`^stStackTests/shallowStackOK\.json`)          // bad hex encoding
+	st.skipLoad(`^stTransactionTest/zeroSigTransa[^/]*\.json`) // EIP-86 is not supported yet
+	// Expected failures:
+	st.fails(`^stCallCreateCallCodeTest/createJS_ExampleContract\.json`, "bug in test")
+	st.fails(`^stCodeSizeLimit/codesizeOOGInvalidSize\.json/(Frontier|Homestead)`,
+		"code size limit implementation is not conditional on fork")
+	st.fails(`^stRevertTest/RevertDepthCreateAddressCollision\.json/EIP15[08]/[67]`, "bug in test")
+	st.fails(`^stRevertTest/RevertPrecompiledTouch\.json/EIP158`, "bug in test")
+	st.fails(`^stRevertTest/RevertPrefoundEmptyOOG\.json/EIP158`, "bug in test")
+
+	st.walk(t, stateTestDir, func(t *testing.T, name string, test *StateTest) {
+		for _, subtest := range test.Subtests() {
+			subtest := subtest
+			key := fmt.Sprintf("%s/%d", subtest.Fork, subtest.Index)
+			name := name + "/" + key
+			t.Run(key, func(t *testing.T) {
+				if subtest.Fork == "Metropolis" {
+					t.Skip("metropolis not supported yet")
+				}
+				withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
+					return st.checkFailure(t, name, test.Run(subtest, vmconfig))
+				})
+			})
 		}
-	}
-}
-
-// homestead tests
-func TestHomesteadDelegateCall(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: big.NewInt(1150000),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stDelegatecallTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStateSystemOperations(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stSystemOperationsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStatePreCompiledContracts(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stPreCompiledContracts.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStateRecursiveCreate(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stSpecialTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStateRefund(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stRefundTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStateInitCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stInitCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStateLog(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stLogTests.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadStateTransaction(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stTransactionTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadCallCreateCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stCallCreateCallCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadCallCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stCallCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadMemory(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stMemoryTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadMemoryStress(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "Homestead", "stMemoryStressTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadQuadraticComplexity(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "Homestead", "stQuadraticComplexityTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadWallet(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stWalletTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadDelegateCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stCallDelegateCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadDelegateCodesCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stCallDelegateCodesCallCode.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHomesteadBounds(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-	}
-
-	fn := filepath.Join(stateTestDir, "Homestead", "stBoundsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-// EIP150 tests
-func TestEIP150Specific(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "stEIPSpecificTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150SingleCodeGasPrice(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "stEIPSingleCodeGasPrices.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150MemExpandingCalls(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "stMemExpandingEIPCalls.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStateSystemOperations(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stSystemOperationsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStatePreCompiledContracts(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stPreCompiledContracts.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStateRecursiveCreate(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stSpecialTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStateRefund(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stRefundTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStateInitCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stInitCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStateLog(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stLogTests.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadStateTransaction(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stTransactionTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadCallCreateCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallCreateCallCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadCallCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadMemory(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stMemoryTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadMemoryStress(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stMemoryStressTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadQuadraticComplexity(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stQuadraticComplexityTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadWallet(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stWalletTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadDelegateCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallDelegateCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadDelegateCodesCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallDelegateCodesCallCode.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP150HomesteadBounds(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stBoundsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-// EIP158 tests
-func TestEIP158Create(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "stCreateTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158Specific(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "stEIP158SpecificTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158NonZeroCalls(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "stNonZeroCallsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158ZeroCalls(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "stZeroCallsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158_150Specific(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "EIP150", "stEIPSpecificTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158_150SingleCodeGasPrice(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "EIP150", "stEIPsingleCodeGasPrices.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158_150MemExpandingCalls(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "EIP150", "stMemExpandingEIPCalls.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadStateSystemOperations(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stSystemOperationsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadStatePreCompiledContracts(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stPreCompiledContracts.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadStateRecursiveCreate(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stSpecialTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadStateRefund(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stRefundTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadStateInitCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stInitCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadStateLog(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stLogTests.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
+	})
 }
 
-func TestEIP158HomesteadStateTransaction(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
+// Transactions with gasLimit above this value will not get a VM trace on failure.
+const traceErrorLimit = 400000
 
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stTransactionTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
+func withTrace(t *testing.T, gasLimit uint64, test func(vm.Config) error) {
+	err := test(vm.Config{})
+	if err == nil {
+		return
 	}
-}
-
-func TestEIP158HomesteadCallCreateCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
+	t.Error(err)
+	if gasLimit > traceErrorLimit {
+		t.Log("gas limit too high for EVM trace")
+		return
 	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stCallCreateCallCodeTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadCallCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stCallCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
+	tracer := vm.NewStructLogger(nil)
+	err2 := test(vm.Config{Debug: true, Tracer: tracer})
+	if !reflect.DeepEqual(err, err2) {
+		t.Errorf("different error for second run: %v", err2)
 	}
-}
-
-func TestEIP158HomesteadMemory(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stMemoryTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadMemoryStress(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stMemoryStressTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadQuadraticComplexity(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	if os.Getenv("TEST_VM_COMPLEX") == "" {
-		t.Skip()
-	}
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stQuadraticComplexityTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadWallet(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stWalletTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadDelegateCodes(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stCallDelegateCodes.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadDelegateCodesCallCode(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stCallDelegateCodesCallCode.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEIP158HomesteadBounds(t *testing.T) {
-	chainConfig := &params.ChainConfig{
-		HomesteadBlock: new(big.Int),
-		EIP150Block:    big.NewInt(2457000),
-		EIP158Block:    params.MainnetChainConfig.EIP158Block,
-	}
-
-	fn := filepath.Join(stateTestDir, "EIP158", "Homestead", "stBoundsTest.json")
-	if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil {
-		t.Error(err)
+	buf := new(bytes.Buffer)
+	vm.WriteTrace(buf, tracer.StructLogs())
+	if buf.Len() == 0 {
+		t.Log("no EVM operation logs generated")
+	} else {
+		t.Log("EVM operation log:\n" + buf.String())
 	}
 }