// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

// OpenEthereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// OpenEthereum 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 General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with OpenEthereum.  If not, see <http://www.gnu.org/licenses/>.

use super::interpreter::MAX_SUB_STACK_SIZE;
use ethereum_types::{Address, H256, U256};
use factory::Factory;
use hex_literal::hex;
use rustc_hex::FromHex;
use std::{
    collections::{HashMap, HashSet},
    fmt::Debug,
    hash::Hash,
    str::FromStr,
    sync::Arc,
};
use vm::{
    self,
    tests::{test_finalize, FakeCall, FakeCallType, FakeExt},
    ActionParams, ActionValue, Ext,
};
use vmtype::VMType;

evm_test! {test_add: test_add_int}
fn test_add(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_988));
    assert_store(
        &ext,
        0,
        "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe",
    );
}

evm_test! {test_sha3: test_sha3_int}
fn test_sha3(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "6000600020600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_961));
    assert_store(
        &ext,
        0,
        "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
    );
}

evm_test! {test_address: test_address_int}
fn test_address(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "30600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
    );
}

evm_test! {test_origin: test_origin_int}
fn test_origin(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let origin = Address::from_str("cd1722f2947def4cf144679da39c4c32bdc35681").unwrap();
    let code = "32600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.origin = origin.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "000000000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681",
    );
}

evm_test! {test_selfbalance: test_selfbalance_int}
fn test_selfbalance(factory: super::Factory) {
    let own_addr = Address::from_str("1337000000000000000000000000000000000000").unwrap();
    // 47       SELFBALANCE
    // 60 ff    PUSH ff
    // 55       SSTORE
    let code = hex!("47 60 ff 55").to_vec();

    let mut params = ActionParams::default();
    params.address = own_addr.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_istanbul();
    ext.balances = {
        let mut x = HashMap::new();
        x.insert(own_addr, U256::from(1_025)); // 0x401
        x
    };
    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };
    assert_eq!(gas_left, U256::from(79_992)); // TODO[dvdplm]: do the sums here, SELFBALANCE-5 + PUSH1-3 + ONEBYTE-4 + SSTORE-?? = 100_000 - 79_992
    assert_store(
        &ext,
        0xff,
        "0000000000000000000000000000000000000000000000000000000000000401",
    );
}

evm_test! {test_sender: test_sender_int}
fn test_sender(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let sender = Address::from_str("cd1722f2947def4cf144679da39c4c32bdc35681").unwrap();
    let code = "33600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.sender = sender.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "000000000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681",
    );
}

evm_test! {test_chain_id: test_chain_id_int}
fn test_chain_id(factory: super::Factory) {
    // 46       CHAINID
    // 60 00    PUSH 0
    // 55       SSTORE
    let code = hex!("46 60 00 55").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_istanbul().with_chain_id(9);

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000009",
    );
}

evm_test! {test_extcodecopy: test_extcodecopy_int}
fn test_extcodecopy(factory: super::Factory) {
    // 33 - sender
    // 3b - extcodesize
    // 60 00 - push 0
    // 60 00 - push 0
    // 33 - sender
    // 3c - extcodecopy
    // 60 00 - push 0
    // 51 - load word from memory
    // 60 00 - push 0
    // 55 - sstore

    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let sender = Address::from_str("cd1722f2947def4cf144679da39c4c32bdc35681").unwrap();
    let code = "333b60006000333c600051600055".from_hex().unwrap();
    let sender_code = "6005600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.sender = sender.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.codes.insert(sender, Arc::new(sender_code));

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_935));
    assert_store(
        &ext,
        0,
        "6005600055000000000000000000000000000000000000000000000000000000",
    );
}

evm_test! {test_log_empty: test_log_empty_int}
fn test_log_empty(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "60006000a0".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(99_619));
    assert_eq!(ext.logs.len(), 1);
    assert_eq!(ext.logs[0].topics.len(), 0);
    assert!(ext.logs[0].data.is_empty());
}

evm_test! {test_log_sender: test_log_sender_int}
fn test_log_sender(factory: super::Factory) {
    // 60 ff - push ff
    // 60 00 - push 00
    // 53 - mstore
    // 33 - sender
    // 60 20 - push 20
    // 60 00 - push 0
    // a1 - log with 1 topic

    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let sender = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
    let code = "60ff6000533360206000a1".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.sender = sender.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(98_974));
    assert_eq!(ext.logs.len(), 1);
    assert_eq!(ext.logs[0].topics.len(), 1);
    assert_eq!(
        ext.logs[0].topics[0],
        H256::from_str("000000000000000000000000cd1722f3947def4cf144679da39c4c32bdc35681").unwrap()
    );
    assert_eq!(
        ext.logs[0].data,
        "ff00000000000000000000000000000000000000000000000000000000000000"
            .from_hex()
            .unwrap()
    );
}

evm_test! {test_blockhash: test_blockhash_int}
fn test_blockhash(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "600040600055".from_hex().unwrap();
    let blockhash =
        H256::from_str("123400000000000000000000cd1722f2947def4cf144679da39c4c32bdc35681").unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.blockhashes.insert(U256::zero(), blockhash.clone());

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_974));
    assert_eq!(ext.store.get(&H256::default()).unwrap(), &blockhash);
}

evm_test! {test_calldataload: test_calldataload_int}
fn test_calldataload(factory: super::Factory) {
    let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "600135600055".from_hex().unwrap();
    let data = "0123ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.address = address.clone();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    params.data = Some(data);
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_991));
    assert_store(
        &ext,
        0,
        "23ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23",
    );
}

evm_test! {test_author: test_author_int}
fn test_author(factory: super::Factory) {
    let author = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
    let code = "41600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.info.author = author;

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
    );
}

evm_test! {test_timestamp: test_timestamp_int}
fn test_timestamp(factory: super::Factory) {
    let timestamp = 0x1234;
    let code = "42600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.info.timestamp = timestamp;

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000001234",
    );
}

evm_test! {test_number: test_number_int}
fn test_number(factory: super::Factory) {
    let number = 0x1234;
    let code = "43600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.info.number = number;

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000001234",
    );
}

evm_test! {test_difficulty: test_difficulty_int}
fn test_difficulty(factory: super::Factory) {
    let difficulty = U256::from(0x1234);
    let code = "44600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.info.difficulty = difficulty;

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000001234",
    );
}

evm_test! {test_gas_limit: test_gas_limit_int}
fn test_gas_limit(factory: super::Factory) {
    let gas_limit = U256::from(0x1234);
    let code = "45600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();
    ext.info.gas_limit = gas_limit;

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(79_995));
    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000001234",
    );
}

evm_test! {test_mul: test_mul_int}
fn test_mul(factory: super::Factory) {
    let code = "65012365124623626543219002600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "000000000000000000000000000000000000000000000000734349397b853383",
    );
    assert_eq!(gas_left, U256::from(79_983));
}

evm_test! {test_sub: test_sub_int}
fn test_sub(factory: super::Factory) {
    let code = "65012365124623626543219003600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000012364ad0302",
    );
    assert_eq!(gas_left, U256::from(79_985));
}

evm_test! {test_div: test_div_int}
fn test_div(factory: super::Factory) {
    let code = "65012365124623626543219004600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "000000000000000000000000000000000000000000000000000000000002e0ac",
    );
    assert_eq!(gas_left, U256::from(79_983));
}

evm_test! {test_div_zero: test_div_zero_int}
fn test_div_zero(factory: super::Factory) {
    let code = "6501236512462360009004600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_eq!(gas_left, U256::from(94_983));
}

evm_test! {test_mod: test_mod_int}
fn test_mod(factory: super::Factory) {
    let code = "650123651246236265432290066000556501236512462360009006600155"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000076b4b",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_eq!(gas_left, U256::from(74_966));
}

evm_test! {test_smod: test_smod_int}
fn test_smod(factory: super::Factory) {
    let code = "650123651246236265432290076000556501236512462360009007600155"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000076b4b",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_eq!(gas_left, U256::from(74_966));
}

evm_test! {test_sdiv: test_sdiv_int}
fn test_sdiv(factory: super::Factory) {
    let code = "650123651246236265432290056000556501236512462360009005600155"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "000000000000000000000000000000000000000000000000000000000002e0ac",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_eq!(gas_left, U256::from(74_966));
}

evm_test! {test_exp: test_exp_int}
fn test_exp(factory: super::Factory) {
    let code = "6016650123651246230a6000556001650123651246230a6001556000650123651246230a600255"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "90fd23767b60204c3d6fc8aec9e70a42a3f127140879c133a20129a597ed0c59",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000012365124623",
    );
    assert_store(
        &ext,
        2,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_eq!(gas_left, U256::from(39_923));
}

evm_test! {test_comparison: test_comparison_int}
fn test_comparison(factory: super::Factory) {
    let code = "601665012365124623818181811060005511600155146002556415235412358014600355"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_store(
        &ext,
        2,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_store(
        &ext,
        3,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_eq!(gas_left, U256::from(49_952));
}

evm_test! {test_signed_comparison: test_signed_comparison_int}
fn test_signed_comparison(factory: super::Factory) {
    let code = "60106000036010818112600055136001556010601060000381811260025513600355"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_store(
        &ext,
        2,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_store(
        &ext,
        3,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_eq!(gas_left, U256::from(49_940));
}

evm_test! {test_bitops: test_bitops_int}
fn test_bitops(factory: super::Factory) {
    let code = "60ff610ff08181818116600055176001551860025560008015600355198015600455600555"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(150_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "00000000000000000000000000000000000000000000000000000000000000f0",
    );
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000fff",
    );
    assert_store(
        &ext,
        2,
        "0000000000000000000000000000000000000000000000000000000000000f0f",
    );
    assert_store(
        &ext,
        3,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_store(
        &ext,
        4,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_store(
        &ext,
        5,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    assert_eq!(gas_left, U256::from(44_937));
}

evm_test! {test_addmod_mulmod: test_addmod_mulmod_int}
fn test_addmod_mulmod(factory: super::Factory) {
    let code = "60ff60f060108282820860005509600155600060f0601082828208196002550919600355"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    assert_store(
        &ext,
        1,
        "000000000000000000000000000000000000000000000000000000000000000f",
    );
    assert_store(
        &ext,
        2,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    assert_store(
        &ext,
        3,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    assert_eq!(gas_left, U256::from(19_914));
}

evm_test! {test_byte: test_byte_int}
fn test_byte(factory: super::Factory) {
    let code = "60f061ffff1a600055610fff601f1a600155".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    assert_store(
        &ext,
        1,
        "00000000000000000000000000000000000000000000000000000000000000ff",
    );
    assert_eq!(gas_left, U256::from(74_976));
}

evm_test! {test_signextend: test_signextend_int}
fn test_signextend(factory: super::Factory) {
    let code = "610fff60020b60005560ff60200b600155".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000fff",
    );
    assert_store(
        &ext,
        1,
        "00000000000000000000000000000000000000000000000000000000000000ff",
    );
    assert_eq!(gas_left, U256::from(59_972));
}

#[test] // JIT just returns out of gas
fn test_badinstruction_int() {
    let factory = super::Factory::new(VMType::Interpreter, 1024 * 32);
    let code = "af".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let err = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap_err()
    };

    match err {
        vm::Error::BadInstruction { instruction: 0xaf } => (),
        _ => assert!(false, "Expected bad instruction"),
    }
}

evm_test! {test_pop: test_pop_int}
fn test_pop(factory: super::Factory) {
    let code = "60f060aa50600055".from_hex().unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "00000000000000000000000000000000000000000000000000000000000000f0",
    );
    assert_eq!(gas_left, U256::from(79_989));
}

evm_test! {test_extops: test_extops_int}
fn test_extops(factory: super::Factory) {
    let code = "5a6001555836553a600255386003553460045560016001526016590454600555"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(150_000);
    params.gas_price = U256::from(0x32);
    params.value = ActionValue::Transfer(U256::from(0x99));
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000004",
    ); // PC / CALLDATASIZE
    assert_store(
        &ext,
        1,
        "00000000000000000000000000000000000000000000000000000000000249ee",
    ); // GAS
    assert_store(
        &ext,
        2,
        "0000000000000000000000000000000000000000000000000000000000000032",
    ); // GASPRICE
    assert_store(
        &ext,
        3,
        "0000000000000000000000000000000000000000000000000000000000000020",
    ); // CODESIZE
    assert_store(
        &ext,
        4,
        "0000000000000000000000000000000000000000000000000000000000000099",
    ); // CALLVALUE
    assert_store(
        &ext,
        5,
        "0000000000000000000000000000000000000000000000000000000000000032",
    );
    assert_eq!(gas_left, U256::from(29_898));
}

evm_test! {test_jumps: test_jumps_int}
fn test_jumps(factory: super::Factory) {
    let code = "600160015560066000555b60016000540380806000551560245760015402600155600a565b"
        .from_hex()
        .unwrap();

    let mut params = ActionParams::default();
    params.gas = U256::from(150_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new();

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(ext.sstore_clears, ext.schedule().sstore_refund_gas as i128);
    assert_store(
        &ext,
        0,
        "0000000000000000000000000000000000000000000000000000000000000000",
    ); // 5!
    assert_store(
        &ext,
        1,
        "0000000000000000000000000000000000000000000000000000000000000078",
    ); // 5!
    assert_eq!(gas_left, U256::from(54_117));
}

evm_test! {test_subs_simple: test_subs_simple_int}
fn test_subs_simple(factory: super::Factory) {
    // as defined in https://eips.ethereum.org/EIPS/eip-2315
    let code = hex!("60045e005c5d").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(18);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_subs_two_levels: test_subs_two_levels_int}
fn test_subs_two_levels(factory: super::Factory) {
    // as defined in https://eips.ethereum.org/EIPS/eip-2315
    let code = hex!("6800000000000000000c5e005c60115e5d5c5d").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(36);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_subs_invalid_jump: test_subs_invalid_jump_int}
fn test_subs_invalid_jump(factory: super::Factory) {
    // as defined in https://eips.ethereum.org/EIPS/eip-2315
    let code = hex!("6801000000000000000c5e005c60115e5d5c5d").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(24);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let current = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap())
    };

    let expected = Result::Err(vm::Error::BadJumpDestination { destination: 0xc });
    assert_eq!(current, expected);
}

evm_test! {test_subs_shallow_return_stack: test_subs_shallow_return_stack_int}
fn test_subs_shallow_return_stack(factory: super::Factory) {
    // as defined in https://eips.ethereum.org/EIPS/eip-2315
    let code = hex!("5d5858").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(24);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let current = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap())
    };

    let expected = Result::Err(vm::Error::SubStackUnderflow {
        wanted: 1,
        on_stack: 0,
    });
    assert_eq!(current, expected);
}

evm_test! {test_subs_substack_limit: test_subs_substack_limit_int}
fn test_subs_substack_limit(factory: super::Factory) {
    //    PUSH <recursion_limit>
    //    JUMP a
    // s: BEGINSUB
    // a: JUMPDEST
    //    DUP1
    //    JUMPI c
    //    STOP
    // c: JUMPDEST
    //    PUSH1 1
    //    SWAP
    //    SUB
    //    JUMPSUB s

    let mut code = hex!("6104006007565c5b80600d57005b6001900360065e").to_vec();
    code[1..3].copy_from_slice(&(MAX_SUB_STACK_SIZE as u16).to_be_bytes()[..]);

    let mut params = ActionParams::default();
    params.gas = U256::from(1_000_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(959_049));
}

evm_test! {test_subs_substack_out: test_subs_substack_out_int}
fn test_subs_substack_out(factory: super::Factory) {
    let mut code = hex!("6104006007565c5b80600d57005b6001900360065e").to_vec();
    code[1..3].copy_from_slice(&((MAX_SUB_STACK_SIZE + 1) as u16).to_be_bytes()[..]);

    let mut params = ActionParams::default();
    params.gas = U256::from(1_000_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let current = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap())
    };

    let expected = Result::Err(vm::Error::OutOfSubStack {
        wanted: 1,
        limit: MAX_SUB_STACK_SIZE,
    });
    assert_eq!(current, expected);
}

evm_test! {test_subs_sub_at_end: test_subs_sub_at_end_int}
fn test_subs_sub_at_end(factory: super::Factory) {
    let code = hex!("6005565c5d5b60035e").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(30);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_subs_walk_into_subroutine: test_subs_walk_into_subroutine_int}
fn test_subs_walk_into_subroutine(factory: super::Factory) {
    let code = hex!("5c5d00").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(100);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(Address::zero(), Address::zero(), &[]);

    let current = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap())
    };

    let expected = Result::Err(vm::Error::InvalidSubEntry);
    assert_eq!(current, expected);
}

evm_test! {test_calls: test_calls_int}
fn test_calls(factory: super::Factory) {
    let code = "600054602d57600160005560006000600060006050610998610100f160006000600060006050610998610100f25b".from_hex().unwrap();

    let address = Address::from_low_u64_be(0x155);
    let code_address = Address::from_low_u64_be(0x998);
    let mut params = ActionParams::default();
    params.gas = U256::from(150_000);
    params.code = Some(Arc::new(code));
    params.address = address.clone();
    let mut ext = FakeExt::new();
    ext.balances = {
        let mut s = HashMap::new();
        s.insert(params.address.clone(), params.gas);
        s
    };

    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_set_contains(
        &ext.calls,
        &FakeCall {
            call_type: FakeCallType::Call,
            create_scheme: None,
            gas: U256::from(2556),
            sender_address: Some(address.clone()),
            receive_address: Some(code_address.clone()),
            value: Some(U256::from(0x50)),
            data: vec![],
            code_address: Some(code_address.clone()),
        },
    );
    assert_set_contains(
        &ext.calls,
        &FakeCall {
            call_type: FakeCallType::Call,
            create_scheme: None,
            gas: U256::from(2556),
            sender_address: Some(address.clone()),
            receive_address: Some(address.clone()),
            value: Some(U256::from(0x50)),
            data: vec![],
            code_address: Some(code_address.clone()),
        },
    );
    assert_eq!(gas_left, U256::from(91_405));
    assert_eq!(ext.calls.len(), 2);
}

evm_test! {test_create_in_staticcall: test_create_in_staticcall_int}
fn test_create_in_staticcall(factory: super::Factory) {
    let code = "600060006064f000".from_hex().unwrap();

    let address = Address::from_low_u64_be(0x155);
    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    params.address = address.clone();
    let mut ext = FakeExt::new_byzantium();
    ext.is_static = true;

    let err = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap_err()
    };

    assert_eq!(err, vm::Error::MutableCallInStaticContext);
    assert_eq!(ext.calls.len(), 0);
}

evm_test! {test_shl: test_shl_int}
fn test_shl(factory: super::Factory) {
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "00",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "01",
        "0000000000000000000000000000000000000000000000000000000000000002",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "ff",
        "8000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "0100",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "0101",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "00",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "01",
        "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "ff",
        "8000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "0100",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "0000000000000000000000000000000000000000000000000000000000000000",
        "01",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1b,
        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "01",
        "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe",
    );
}

evm_test! {test_shr: test_shr_int}
fn test_shr(factory: super::Factory) {
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "00",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "01",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "01",
        "4000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "ff",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "0100",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "0101",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "00",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "01",
        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "ff",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "0100",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1c,
        "0000000000000000000000000000000000000000000000000000000000000000",
        "01",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
}

evm_test! {test_sar: test_sar_int}
fn test_sar(factory: super::Factory) {
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "00",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "0000000000000000000000000000000000000000000000000000000000000001",
        "01",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "01",
        "c000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "ff",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "0100",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "8000000000000000000000000000000000000000000000000000000000000000",
        "0101",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "00",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "01",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "ff",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "0100",
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "0000000000000000000000000000000000000000000000000000000000000000",
        "01",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "4000000000000000000000000000000000000000000000000000000000000000",
        "fe",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "f8",
        "000000000000000000000000000000000000000000000000000000000000007f",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "fe",
        "0000000000000000000000000000000000000000000000000000000000000001",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "ff",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
    push_two_pop_one_constantinople_test(
        &factory,
        0x1d,
        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
        "0100",
        "0000000000000000000000000000000000000000000000000000000000000000",
    );
}

// from https://gist.github.com/holiman/174548cad102096858583c6fbbb0649a
evm_test! {test_access_list_ext_at_precompiles: test_access_list_ext_at_precompiles_int}
fn test_access_list_ext_at_precompiles(factory: super::Factory) {
    // 6001 3f 50
    // 6002 3b 50
    // 6003 31 50
    // 60f1 3f 50
    // 60f2 3b 50
    // 60f3 31 50
    // 60f2 3f 50
    // 60f3 3b 50
    // 60f1 31 50
    // 32 31 50
    // 30 31 50
    // 00

    let code = hex!(
        "60013f5060023b506003315060f13f5060f23b5060f3315060f23f5060f33b5060f1315032315030315000"
    )
    .to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(8653);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(
        Address::from_str("0000000000000000000000000000000000000000").unwrap(),
        Address::from_str("000000000000000000000000636F6E7472616374").unwrap(),
        &[
            Address::from_str("0000000000000000000000000000000000000001").unwrap(),
            Address::from_str("0000000000000000000000000000000000000002").unwrap(),
            Address::from_str("0000000000000000000000000000000000000003").unwrap(),
        ],
    );
    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_access_list_extcodecopy_twice: test_access_list_extcodecopy_twice_int}
fn test_access_list_extcodecopy_twice(factory: super::Factory) {
    let code = hex!("60006000600060ff3c60006000600060ff3c600060006000303c").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(2835);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(
        Address::from_str("0000000000000000000000000000000000000000").unwrap(),
        Address::from_str("000000000000000000000000636F6E7472616374").unwrap(),
        &[],
    );
    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_access_list_sload_sstore: test_access_list_sload_sstore_int}
fn test_access_list_sload_sstore(factory: super::Factory) {
    // 6001 54 50    sload( 0x1) pop
    // 6011 6001 55  sstore(loc: 0x01, val:0x11) 20000
    // 6011 6002 55  sstore(loc: 0x02, val:0x11) 20000 + 2100
    // 6011 6002 55  sstore(loc: 0x02, val:0x11) 100
    // 6002 54       sload(0x2)
    // 6001 54       sload(0x1)
    let code = hex!("60015450 6011600155 6011600255 6011600255 600254 600154").to_vec();

    let mut params = ActionParams::default();
    params.gas = U256::from(44529);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(
        Address::from_str("0000000000000000000000000000000000000000").unwrap(),
        Address::from_str("000000000000000000000000636F6E7472616374").unwrap(),
        &[],
    );
    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_access_list_cheap_expensive_cheap: test_access_list_cheap_expensive_cheap_int}
fn test_access_list_cheap_expensive_cheap(factory: super::Factory) {
    let code =
        hex!("60008080808060046000f15060008080808060ff6000f15060008080808060ff6000fa50").to_vec();
    let mut params = ActionParams::default();
    params.gas = U256::from(2869);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_berlin(
        Address::from_str("0000000000000000000000000000000000000000").unwrap(),
        Address::from_str("000000000000000000000000636F6E7472616374").unwrap(),
        &[Address::from_str("0000000000000000000000000000000000000004").unwrap()],
    );
    let gas_left = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_eq!(gas_left, U256::from(0));
}

evm_test! {test_refund_post_london: test_refund_post_london_int}
fn test_refund_post_london(factory: super::Factory) {
    // Compare EIP-3529 for the test cases

    let code = hex!("60006000556000600055").to_vec();
    london_refund_test(&factory, code, &[], 0);

    let code = hex!("60006000556001600055").to_vec();
    london_refund_test(&factory, code, &[], 0);

    let code = hex!("60016000556000600055").to_vec();
    london_refund_test(&factory, code, &[], 19900);

    let code = hex!("60006000556000600055").to_vec();
    london_refund_test(&factory, code, &[1], 4800);

    let code = hex!("60006000556001600055").to_vec();
    london_refund_test(&factory, code, &[1], 2800);

    let code = hex!("60006000556002600055").to_vec();
    london_refund_test(&factory, code, &[1], 0);

    let code = hex!("60026000556000600055").to_vec();
    london_refund_test(&factory, code, &[1], 4800);

    let code = hex!("60026000556001600055").to_vec();
    london_refund_test(&factory, code, &[1], 2800);

    let code = hex!("60016000556000600055").to_vec();
    london_refund_test(&factory, code, &[], 19900);

    let code = hex!("600060005560016000556000600055").to_vec();
    london_refund_test(&factory, code, &[1], 7600);
}

fn london_refund_test(
    factory: &super::Factory,
    code: Vec<u8>,
    fill: &[u64],
    expected_refund: i128,
) {
    let mut params = ActionParams::default();
    params.gas = U256::from(22318);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_london(
        Address::from_str("0000000000000000000000000000000000000000").unwrap(),
        Address::from_str("000000000000000000000000636F6E7472616374").unwrap(),
        &[],
    );
    ext.prefill(fill);
    let vm = factory.create(params, ext.schedule(), ext.depth());
    vm.exec(&mut ext).ok().unwrap().unwrap();
    assert_eq!(ext.sstore_clears, expected_refund);
}

fn push_two_pop_one_constantinople_test(
    factory: &super::Factory,
    opcode: u8,
    push1: &str,
    push2: &str,
    result: &str,
) {
    let mut push1 = push1.from_hex().unwrap();
    let mut push2 = push2.from_hex().unwrap();
    assert!(push1.len() <= 32 && push1.len() != 0);
    assert!(push2.len() <= 32 && push2.len() != 0);

    let mut code = Vec::new();
    code.push(0x60 + ((push1.len() - 1) as u8));
    code.append(&mut push1);
    code.push(0x60 + ((push2.len() - 1) as u8));
    code.append(&mut push2);
    code.push(opcode);
    code.append(&mut vec![0x60, 0x00, 0x55]);

    let mut params = ActionParams::default();
    params.gas = U256::from(100_000);
    params.code = Some(Arc::new(code));
    let mut ext = FakeExt::new_constantinople();

    let _ = {
        let vm = factory.create(params, ext.schedule(), ext.depth());
        test_finalize(vm.exec(&mut ext).ok().unwrap()).unwrap()
    };

    assert_store(&ext, 0, result);
}

fn assert_set_contains<T: Debug + Eq + PartialEq + Hash>(set: &HashSet<T>, val: &T) {
    let contains = set.contains(val);
    if !contains {
        println!("Set: {:?}", set);
        println!("Elem: {:?}", val);
    }
    assert!(contains, "Element not found in HashSet");
}

fn assert_store(ext: &FakeExt, pos: u64, val: &str) {
    assert_eq!(
        ext.store.get(&H256::from_low_u64_be(pos)).unwrap(),
        &H256::from_str(val).unwrap()
    );
}