gaspersic/go-ethereum
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

core: added basic chain configuration

Browse Source 
Added chain configuration options and write out during genesis database
insertion. If no "config" was found, nothing is written to the database.

Configurations are written on a per genesis base. This means
that any chain (which is identified by it's genesis hash) can have their
own chain settings.
This commit is contained in:
Jeffrey Wilcke
2016-03-01 23:32:43 +01:00
committed by Jeffrey Wilcke
parent 10d3466c93
commit f0cbebb19f
55 changed files with 732 additions and 431 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
tests/state_test.go
View File

@ -21,18 +21,8 @@ import (
"os"
"path/filepath"
"testing"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/params"
)
func init() {
if os.Getenv("JITVM") == "true" {
vm.ForceJit = true
vm.EnableJit = true
}
}
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 {
@ -41,188 +31,228 @@ func BenchmarkStateCall1024(b *testing.B) {
}
func TestStateSystemOperations(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stSystemOperationsTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateExample(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stExample.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStatePreCompiledContracts(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stPreCompiledContracts.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateRecursiveCreate(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stRecursiveCreate.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateSpecial(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stSpecialTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateRefund(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stRefundTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateBlockHash(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stBlockHashTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateInitCode(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stInitCodeTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateLog(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stLogTests.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateTransaction(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stTransactionTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateTransition(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stTransitionTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestCallCreateCallCode(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stCallCreateCallCodeTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestCallCodes(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stCallCodes.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestDelegateCall(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stDelegatecallTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestMemory(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stMemoryTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestMemoryStress(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
if os.Getenv("TEST_VM_COMPLEX") == "" {
t.Skip()
}
fn := filepath.Join(stateTestDir, "stMemoryStressTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestQuadraticComplexity(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
if os.Getenv("TEST_VM_COMPLEX") == "" {
t.Skip()
}
fn := filepath.Join(stateTestDir, "stQuadraticComplexityTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestSolidity(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stSolidityTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestWallet(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fn := filepath.Join(stateTestDir, "stWalletTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestStateTestsRandom(t *testing.T) {
params.HomesteadBlock = big.NewInt(1000000)
ruleSet := RuleSet{
HomesteadBlock: big.NewInt(1000000),
}
fns, _ := filepath.Glob("./files/StateTests/RandomTests/*")
for _, fn := range fns {
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
@ -230,151 +260,172 @@ func TestStateTestsRandom(t *testing.T) {
// homestead tests
func TestHomesteadStateSystemOperations(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stSystemOperationsTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadStatePreCompiledContracts(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stPreCompiledContracts.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadStateRecursiveCreate(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
fn := filepath.Join(stateTestDir, "Homestead", "stRecursiveCreate.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
t.Error(err)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
}
func TestHomesteadStateSpecial(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
fn := filepath.Join(stateTestDir, "Homestead", "stSpecialTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadStateRefund(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stRefundTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadStateInitCode(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stInitCodeTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadStateLog(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stLogTests.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadStateTransaction(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stTransactionTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadCallCreateCallCode(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stCallCreateCallCodeTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadCallCodes(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stCallCodes.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadMemory(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stMemoryTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadMemoryStress(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
if os.Getenv("TEST_VM_COMPLEX") == "" {
t.Skip()
}
fn := filepath.Join(stateTestDir, "Homestead", "stMemoryStressTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadQuadraticComplexity(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
if os.Getenv("TEST_VM_COMPLEX") == "" {
t.Skip()
}
fn := filepath.Join(stateTestDir, "Homestead", "stQuadraticComplexityTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadWallet(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stWalletTest.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadDelegateCodes(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stCallDelegateCodes.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}
func TestHomesteadDelegateCodesCallCode(t *testing.T) {
params.HomesteadBlock = big.NewInt(0)
ruleSet := RuleSet{
HomesteadBlock: new(big.Int),
}
fn := filepath.Join(stateTestDir, "Homestead", "stCallDelegateCodesCallCode.json")
if err := RunStateTest(fn, StateSkipTests); err != nil {
if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil {
t.Error(err)
}
}