112 lines
3.9 KiB
Rust
112 lines
3.9 KiB
Rust
// 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::test_common::*;
|
|
use client::EvmTestClient;
|
|
use ethjson;
|
|
use std::path::Path;
|
|
use transaction_ext::Transaction;
|
|
use types::{
|
|
header::Header,
|
|
transaction::{TypedTransaction, UnverifiedTransaction},
|
|
};
|
|
|
|
pub fn json_transaction_test<H: FnMut(&str, HookType)>(
|
|
path: &Path,
|
|
json_data: &[u8],
|
|
start_stop_hook: &mut H,
|
|
) -> Vec<String> {
|
|
// Block number used to run the tests.
|
|
// Make sure that all the specified features are activated.
|
|
const BLOCK_NUMBER: u64 = 0x6ffffffffffffe;
|
|
|
|
let tests = ethjson::transaction::Test::load(json_data).expect(&format!(
|
|
"Could not parse JSON transaction test data from {}",
|
|
path.display()
|
|
));
|
|
let mut failed = Vec::new();
|
|
for (name, test) in tests.into_iter() {
|
|
if !super::debug_include_test(&name) {
|
|
continue;
|
|
}
|
|
|
|
start_stop_hook(&name, HookType::OnStart);
|
|
|
|
println!(" - tx: {} ", name);
|
|
|
|
for (spec_name, result) in test.post_state {
|
|
let spec = match EvmTestClient::spec_from_json(&spec_name) {
|
|
Some(spec) => spec,
|
|
None => {
|
|
failed.push(format!("{}-{:?} (missing spec)", name, spec_name));
|
|
continue;
|
|
}
|
|
};
|
|
|
|
let mut fail_unless = |cond: bool, title: &str| {
|
|
if !cond {
|
|
failed.push(format!("{}-{:?}", name, spec_name));
|
|
println!(
|
|
"Transaction failed: {:?}-{:?}: {:?}",
|
|
name, spec_name, title
|
|
);
|
|
}
|
|
};
|
|
|
|
let rlp: Vec<u8> = test.rlp.clone().into();
|
|
let res = TypedTransaction::decode(&rlp)
|
|
.map_err(::error::Error::from)
|
|
.and_then(|t: UnverifiedTransaction| {
|
|
let mut header: Header = Default::default();
|
|
// Use high enough number to activate all required features.
|
|
header.set_number(BLOCK_NUMBER);
|
|
|
|
let minimal = t
|
|
.tx()
|
|
.gas_required(&spec.engine.schedule(header.number()))
|
|
.into();
|
|
if t.tx().gas < minimal {
|
|
return Err(::types::transaction::Error::InsufficientGas {
|
|
minimal,
|
|
got: t.tx().gas,
|
|
}
|
|
.into());
|
|
}
|
|
spec.engine.verify_transaction_basic(&t, &header)?;
|
|
Ok(spec.engine.verify_transaction_unordered(t, &header)?)
|
|
});
|
|
|
|
match (res, result.hash, result.sender) {
|
|
(Ok(t), Some(hash), Some(sender)) => {
|
|
fail_unless(t.sender() == sender.into(), "sender mismatch");
|
|
fail_unless(t.hash() == hash.into(), "hash mismatch");
|
|
}
|
|
(Err(_), None, None) => {}
|
|
data => {
|
|
fail_unless(false, &format!("Validity different: {:?}", data));
|
|
}
|
|
}
|
|
}
|
|
|
|
start_stop_hook(&name, HookType::OnStop);
|
|
}
|
|
|
|
for f in &failed {
|
|
println!("FAILED: {:?}", f);
|
|
}
|
|
failed
|
|
}
|