fluencelabs/parity-wasm
1
0
Fork 0
mirror of https://github.com/fluencelabs/parity-wasm synced 2025-06-30 07:02:43 +00:00
Code Issues Projects Releases Wiki Activity

merge 2 error enums

Browse Source
This commit is contained in:
Svyatoslav Nikolsky
2017-08-01 14:44:33 +03:00
parent a02fdf5836
commit 9437b7bdfc
20 changed files with 457 additions and 475 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/interpreter/tests/basics.rs
View File

@ -5,7 +5,7 @@ use std::collections::HashMap;
use builder::module;
use elements::{ExportEntry, Internal, ImportEntry, External, GlobalEntry, GlobalType,
InitExpr, ValueType, BlockType, Opcodes, Opcode, FunctionType};
use interpreter::{Error, CustomUserError, DummyCustomUserError, InterpreterError, ProgramInstance, ModuleInstance, CustomProgramInstance};
use interpreter::{Error, CustomUserError, ProgramInstance, DefaultProgramInstance, DefaultModuleInstance};
use interpreter::env_native::{env_native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor};
use interpreter::memory::MemoryInstance;
use interpreter::module::{ModuleInstanceInterface, CallerContext, ItemIndex, ExecutionParams, ExportEntryType, FunctionSignature};
@ -39,7 +39,7 @@ fn import_function() {
.build()
.build();
let program = ProgramInstance::new().unwrap();
let program = DefaultProgramInstance::new().unwrap();
let external_module = program.add_module("external_module", module1, None).unwrap();
let main_module = program.add_module("main", module2, None).unwrap();
@ -73,7 +73,7 @@ fn wrong_import() {
.build()
.build();
let program = ProgramInstance::new().unwrap();
let program = DefaultProgramInstance::new().unwrap();
let _side_module_instance = program.add_module("side_module", side_module, None).unwrap();
assert!(program.add_module("main", module, None).is_err());
}
@ -95,7 +95,7 @@ fn global_get_set() {
.build()
.build();
let program = ProgramInstance::new().unwrap();
let program = DefaultProgramInstance::new().unwrap();
let module = program.add_module("main", module, None).unwrap();
assert_eq!(module.execute_index(0, vec![].into()).unwrap().unwrap(), RuntimeValue::I32(50));
assert_eq!(module.execute_index(0, vec![].into()).unwrap().unwrap(), RuntimeValue::I32(58));
@ -128,12 +128,12 @@ struct MeasuredVariable {
pub val: i32,
}
impl ExternalVariableValue for MeasuredVariable {
impl ExternalVariableValue<UserError> for MeasuredVariable {
fn get(&self) -> RuntimeValue {
RuntimeValue::I32(self.val)
}
fn set(&mut self, val: RuntimeValue) -> Result<(), Error> {
fn set(&mut self, val: RuntimeValue) -> Result<(), Error<UserError>> {
self.val = val.try_into()?;
Ok(())
}
@ -155,12 +155,12 @@ impl CustomUserError for UserError {}
// user function executor
struct FunctionExecutor {
pub memory: Arc<MemoryInstance>,
pub memory: Arc<MemoryInstance<UserError>>,
pub values: Vec<i32>,
}
impl UserFunctionExecutor<UserError> for FunctionExecutor {
fn execute(&mut self, name: &str, context: CallerContext<UserError>) -> Result<Option<RuntimeValue>, InterpreterError<UserError>> {
fn execute(&mut self, name: &str, context: CallerContext<UserError>) -> Result<Option<RuntimeValue>, Error<UserError>> {
match name {
"add" => {
let memory_value = self.memory.get(0, 1).unwrap()[0];
@ -185,7 +185,7 @@ impl UserFunctionExecutor<UserError> for FunctionExecutor {
Ok(Some(RuntimeValue::I32(diff as i32)))
},
"err" => {
Err(InterpreterError::User(UserError { error_code: 777 }))
Err(Error::User(UserError { error_code: 777 }))
},
_ => Err(Error::Trap("not implemented".into()).into()),
}
@ -195,7 +195,7 @@ impl UserFunctionExecutor<UserError> for FunctionExecutor {
#[test]
fn native_env_function() {
// create new program
let program = CustomProgramInstance::new().unwrap();
let program = ProgramInstance::new().unwrap();
// => env module is created
let env_instance = program.module("env").unwrap();
// => linear memory is created
@ -305,7 +305,7 @@ fn native_env_global() {
#[test]
fn native_custom_error() {
let program = CustomProgramInstance::new().unwrap();
let program = ProgramInstance::new().unwrap();
let env_instance = program.module("env").unwrap();
let env_memory = env_instance.memory(ItemIndex::Internal(0)).unwrap();
let mut executor = FunctionExecutor { memory: env_memory.clone(), values: Vec::new() };
@ -332,14 +332,14 @@ fn native_custom_error() {
let module_instance = program.add_module("main", module, Some(&params.externals)).unwrap();
assert_eq!(module_instance.execute_index(0, params.clone().add_argument(RuntimeValue::I32(7)).add_argument(RuntimeValue::I32(0))),
Err(InterpreterError::User(UserError { error_code: 777 })));
Err(Error::User(UserError { error_code: 777 })));
assert_eq!(module_instance.execute_index(1, params.clone().add_argument(RuntimeValue::I32(7)).add_argument(RuntimeValue::I32(0))),
Err(InterpreterError::User(UserError { error_code: 777 })));
Err(Error::User(UserError { error_code: 777 })));
}
#[test]
fn import_env_mutable_global() {
let program = ProgramInstance::new().unwrap();
let program = DefaultProgramInstance::new().unwrap();
let module = module()
.with_import(ImportEntry::new("env".into(), "STACKTOP".into(), External::Global(GlobalType::new(ValueType::I32, false))))
@ -350,7 +350,7 @@ fn import_env_mutable_global() {
#[test]
fn env_native_export_entry_type_check() {
let program = CustomProgramInstance::new().unwrap();
let program = ProgramInstance::new().unwrap();
let mut function_executor = FunctionExecutor {
memory: program.module("env").unwrap().memory(ItemIndex::Internal(0)).unwrap(),
values: Vec::new(),
@ -369,7 +369,7 @@ fn env_native_export_entry_type_check() {
#[test]
fn if_else_with_return_type_validation() {
let module_instance = ModuleInstance::new(Weak::default(), "test".into(), module().build()).unwrap();
let module_instance = DefaultModuleInstance::new(Weak::default(), "test".into(), module().build()).unwrap();
let mut context = FunctionValidationContext::new(&module_instance, None, &[], 1024, 1024, FunctionSignature::Module(&FunctionType::default()));
Validator::validate_function(&mut context, BlockType::NoResult, &[